Struct SliceWriter

pub(crate) struct SliceWriter<T> {
    data: T,
    offset: usize,
}

An object that supports writing into a byte-slice of fixed size.

Since the writer API does not allow all write_* functions to report errors, this type defers any truncated-data errors until you try to retrieve the inner data.

Fields

data: T

The object we’re writing into. Must have fewer than usize::LEN bytes.

offset: usize

Our current write position within that object.

Implementations

impl<T> SliceWriter<T>

where T: AsMut<[u8]>,

pub(crate) fn advance(&mut self, n: usize)

Move this writer ahead by n bytes, leaving the original data unchanged.

impl<T> SliceWriter<T>

pub(crate) fn new(data: T) -> Self

Construct a new SliceWriter

Typically, you would want to use this on a type that implements AsMut<[u8]>, or else it won’t be very useful.

Preexisting bytes in the data object will be unchanged, unless you use the [Writer] API to write to them.

pub(crate) fn try_unwrap(self) -> Result<(T, usize), SliceWriterError>

Try to extract the data from this SliceWriter.

On success (if we did not write “off the end” of the underlying object), return the object and the number of bytes we wrote into it. (Bytes after that position are unchanged.)

On failure (if we tried to write too much), return an error.

pub(crate) fn offset(&self) -> Result<usize, SliceWriterError>

Return the number of bytes written into this SliceWriter so far, or an error if it has overflowed.

pub(crate) fn assert_offset_is(&self, n: usize)

debug_assert that this writer is at position n.

Panics

Panics if debugging assertions are enabled and the write has overflowed, or is at a position other than n.

Trait Implementations

impl<T> Writer for SliceWriter<T>

where T: AsMut<[u8]>,

fn write_all(&mut self, b: &[u8])

Append a slice to the end of this writer.

fn write_u8(&mut self, x: u8)

Append a single u8 to this writer.

fn write_u16(&mut self, x: u16)

Append a single u16 to this writer, encoded in big-endian order.

fn write_u32(&mut self, x: u32)

Append a single u32 to this writer, encoded in big-endian order.

fn write_u64(&mut self, x: u64)

Append a single u64 to this writer, encoded in big-endian order.

fn write_u128(&mut self, x: u128)

Append a single u128 to this writer, encoded in big-endian order.

fn write_zeros(&mut self, n: usize)

Write n bytes to this writer, all with the value zero.

fn write<E>(&mut self, e: &E) -> Result<(), EncodeError>

where E: Writeable + ?Sized,

Encode a Writeable object onto this writer, using its write_onto method.

fn write_and_consume<E>(&mut self, e: E) -> Result<(), EncodeError>

where E: WriteableOnce,

Encode a WriteableOnce object onto this writer, using its write_into method.

fn write_nested_u8len(&mut self) -> NestedWriter<'_, Self, u8>

Arranges to write a u8 length, and some data whose encoding is that length

fn write_nested_u16len(&mut self) -> NestedWriter<'_, Self, u16>

Arranges to writes a u16 length and some data whose encoding is that length

fn write_nested_u32len(&mut self) -> NestedWriter<'_, Self, u32>

Arranges to writes a u32 length and some data whose encoding is that length