Enum rustls::crypto::cipher::OutboundChunks

pub enum OutboundChunks<'a> {
    Single(&'a [u8]),
    Multiple {
        chunks: &'a [&'a [u8]],
        start: usize,
        end: usize,
    },
}

A collection of borrowed plaintext slices.

Warning: OutboundChunks does not guarantee that the simplest variant is used. Multiple can hold non fragmented or empty payloads.

Variants

Single(&'a [u8])

A single byte slice. Contrary to Multiple, this uses a single pointer indirection

Multiple

A collection of chunks (byte slices) and cursors to single out a fragmented range of bytes. OutboundChunks assumes that start <= end

Fields

chunks: &'a [&'a [u8]]

start: usize

end: usize

Implementations

impl<'a> OutboundChunks<'a>

pub fn new(chunks: &'a [&'a [u8]]) -> Self

Create a payload from a slice of byte slices. If fragmented the cursors are added by default: start = 0, end = length

pub fn new_empty() -> Self

Create a payload with a single empty slice

pub fn to_vec(&self) -> Vec<u8>

Flatten the slice of byte slices to an owned vector of bytes

pub fn copy_to_vec(&self, vec: &mut Vec<u8>)

Append all bytes to a vector

pub fn split_at(&self, mid: usize) -> (Self, Self)

Split self in two, around an index Works similarly to split_at in the core library, except it doesn’t panic if out of bound

pub fn is_empty(&self) -> bool

Returns true if the payload is empty

pub fn len(&self) -> usize

Returns the cumulative length of all chunks

Trait Implementations

impl<'a> Clone for OutboundChunks<'a>

fn clone(&self) -> OutboundChunks<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for OutboundChunks<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a [u8]> for OutboundChunks<'a>

fn from(payload: &'a [u8]) -> Self

Converts to this type from the input type.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes

Size for each variant:

• Single: 24 bytes
• Multiple: 32 bytes