Struct s2n_codec::encoder::scatter::Buffer

pub struct Buffer<'a> { /* private fields */ }

Implementations

impl<'a> Buffer<'a>

pub fn flatten(&mut self) -> &mut EncoderBuffer<'a>

Ensures an extra bytes are written into the main EncoderBuffer.

impl<'a> Buffer<'a>

Implement a version with bytes enabled

pub fn new(inner: EncoderBuffer<'a>) -> Self

Initializes a buffer without any extra bytes at the end

pub fn new_with_extra(inner: EncoderBuffer<'a>, extra: Option<Bytes>) -> Self

Initializes the buffer with extra bytes

NOTE the EncoderBuffer position should not include the extra bytes. This ensures the bytes can be “flushed” into the EncoderBuffer if another write happens or flatten is called.

pub fn into_inner(self) -> (EncoderBuffer<'a>, Option<Bytes>)

Converts the buffer into its inner parts

NOTE: the EncoderBuffer position will not include the extra bytes. The caller will need to account for this data.

pub fn inner_mut(&mut self) -> (&mut EncoderBuffer<'a>, &Option<Bytes>)

Returns the inner EncoderBuffer, along with the current extra bytes

pub fn clear(&mut self)

Resets the encoder to its initial state while also dropping any extra bytes at the end

Trait Implementations

impl<'a> Encoder for Buffer<'a>

const SPECIALIZES_BYTES: bool = true

We have special handling for writes that include Bytes so signal that

fn write_sized<F: FnOnce(&mut [u8])>(&mut self, len: usize, write: F)

Calls write with a slice of len bytes at the current write position

fn write_slice(&mut self, slice: &[u8])

Copies the slice into the buffer

fn write_bytes(&mut self, bytes: Bytes)

fn write_zerocopy<T: AsBytes + FromBytes + Unaligned, F: FnOnce(&mut T)>( &mut self, write: F )

Writes a zerocopy value to the buffer

fn write_repeated(&mut self, count: usize, value: u8)

Repeatedly write a byte value for a given count

fn capacity(&self) -> usize

Returns the total buffer capacity

fn len(&self) -> usize

Returns the number of bytes written to the buffer

fn encode<T: EncoderValue>(&mut self, value: &T)

Encode the given EncoderValue into the buffer

fn encode_with_len_prefix<Len: TryFrom<usize> + EncoderValue, T: EncoderValue>( &mut self, value: &T )

where Len::Error: Debug,

Encode the given EncoderValue into the buffer with a prefix of Len

fn is_empty(&self) -> bool

Returns true if no bytes have been written

fn remaining_capacity(&self) -> usize

Returns the number of available bytes in the buffer