Struct solana_streamer::packet::PacketBatch

pub struct PacketBatch {
    packets: PinnedVec<Packet>,
}

Fields

packets: PinnedVec<Packet>

Implementations

impl PacketBatch

pub fn new(packets: Vec<Packet, Global>) -> PacketBatch

pub fn with_capacity(capacity: usize) -> PacketBatch

pub fn new_pinned_with_capacity(capacity: usize) -> PacketBatch

pub fn new_unpinned_with_recycler( recycler: Recycler<PinnedVec<Packet>>, capacity: usize, name: &'static str ) -> PacketBatch

pub fn new_with_recycler( recycler: Recycler<PinnedVec<Packet>>, capacity: usize, name: &'static str ) -> PacketBatch

pub fn new_with_recycler_data( recycler: &Recycler<PinnedVec<Packet>>, name: &'static str, packets: Vec<Packet, Global> ) -> PacketBatch

pub fn new_unpinned_with_recycler_data_and_dests<T>( recycler: Recycler<PinnedVec<Packet>>, name: &'static str, dests_and_data: &[(SocketAddr, T)] ) -> PacketBatchwhere T: Serialize,

pub fn new_unpinned_with_recycler_data( recycler: &Recycler<PinnedVec<Packet>>, name: &'static str, packets: Vec<Packet, Global> ) -> PacketBatch

pub fn resize(&mut self, new_len: usize, value: Packet)

pub fn truncate(&mut self, len: usize)

pub fn push(&mut self, packet: Packet)

pub fn set_addr(&mut self, addr: &SocketAddr)

pub fn len(&self) -> usize

pub fn capacity(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn as_ptr(&self) -> *const Packet

pub fn iter(&self) -> Iter<'_, Packet>

pub fn iter_mut(&mut self) -> IterMut<'_, Packet>

pub unsafe fn set_len(&mut self, new_len: usize)

See Vector::set_len() for more details

Safety

• new_len must be less than or equal to [self.capacity].
• The elements at old_len..new_len must be initialized. Packet data will likely be overwritten when populating the packet, but the meta should specifically be initialized to known values.

Trait Implementations

impl Clone for PacketBatch

fn clone(&self) -> PacketBatch

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PacketBatch

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for PacketBatch

fn default() -> PacketBatch

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PacketBatch

fn deserialize<__D>( __deserializer: __D ) -> Result<PacketBatch, <__D as Deserializer<'de>>::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<PacketBatch> for Vec<Packet, Global>

fn from(batch: PacketBatch) -> Vec<Packet, Global>

Converts to this type from the input type.

impl<I> Index<I> for PacketBatchwhere I: SliceIndex<[Packet]>,

type Output = <I as SliceIndex<[Packet]>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &<PacketBatch as Index<I>>::Output

Performs the indexing (container[index]) operation.

impl<I> IndexMut<I> for PacketBatchwhere I: SliceIndex<[Packet]>,

fn index_mut(&mut self, index: I) -> &mut <PacketBatch as Index<I>>::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IntoIterator for &'a PacketBatch

type Item = &'a Packet

The type of the elements being iterated over.

type IntoIter = Iter<'a, Packet>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a PacketBatch as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a> IntoParallelIterator for &'a PacketBatch

type Iter = Iter<'a, Packet>

The parallel iterator type that will be created.

type Item = &'a Packet

The type of item that the parallel iterator will produce.

fn into_par_iter(self) -> <&'a PacketBatch as IntoParallelIterator>::Iter

Converts self into a parallel iterator.

impl<'a> IntoParallelIterator for &'a mut PacketBatch

type Iter = IterMut<'a, Packet>

The parallel iterator type that will be created.

type Item = &'a mut Packet

The type of item that the parallel iterator will produce.

fn into_par_iter(self) -> <&'a mut PacketBatch as IntoParallelIterator>::Iter

Converts self into a parallel iterator.

impl Serialize for PacketBatch

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.