Struct typed_bytes::ByteBuilder

pub struct ByteBuilder<T> {
    buffer: Vec<u8>,
    phantom: PhantomData<T>,
    expected: Option<NonZeroUsize>,
}

A dynamically created buffer for T

Fields

buffer: Vec<u8>

phantom: PhantomData<T>

expected: Option<NonZeroUsize>

Implementations

impl<T> ByteBuilder<T>

pub fn new() -> Self

Create an unconstrained Builder

pub fn new_fixed(size: NonZeroUsize) -> Self

Create a builder of fixed size

pub fn u8(self, v: u8) -> Self

Append an u8 in the builder

pub fn bytes(self, v: &[u8]) -> Self

Append bytes in the builder

pub fn fold<F, I>(self, l: I, f: F) -> Selfwhere I: Iterator, F: FnMut(Self, I::Item) -> Self,

fold over an iterator

pub fn iter8<F, I>(self, l: I, f: F) -> Selfwhere I: IntoIterator, I::IntoIter: ExactSizeIterator, F: FnMut(Self, I::Item) -> Self,

Write an iterator of maximum 255 items using the closure f.

Note that the buffer contains a byte to represent the size of the list.

pub fn iter16<F, I>(self, l: I, f: F) -> Selfwhere I: IntoIterator, I::IntoIter: ExactSizeIterator, F: FnMut(Self, I::Item) -> Self,

Write an iterator of maximum 2^16 - 1 items using the closure f.

Note that the buffer contains 2 bytes to represent the size of the list.

pub fn iter32<F, I>(self, l: I, f: F) -> Selfwhere I: IntoIterator, I::IntoIter: ExactSizeIterator, F: FnMut(Self, I::Item) -> Self,

Write an iterator of maximum 2^32 - 1 items using the closure f.

Note that the buffer contains 4 bytes to represent the size of the list.

pub fn sub<F, U>(self, f: F) -> Selfwhere F: Fn(ByteBuilder<U>) -> ByteBuilder<U>,

pub fn u16(self, v: u16) -> Self

Append an u16 in the builder

pub fn u32(self, v: u32) -> Self

Append an u32 in the builder

pub fn u64(self, v: u64) -> Self

Append an u64 in the builder

pub fn u128(self, v: u128) -> Self

Append an u128 in the builder

pub fn option<F, V>(self, value: Option<V>, f: F) -> Selfwhere F: FnOnce(Self, V) -> Self,

Call ‘f’ on bytebuilder and the value if the value is present, then return the bytebuilder, otherwise just return the bytebuilder

pub fn option_or_else<F, G, V>(self, value: Option<V>, default: G, f: F) -> Selfwhere F: FnOnce(Self, V) -> Self, G: FnOnce(Self) -> Self,

Run the first closure if the value is not present, or the second closure with the present parameter.

this is loosely based on Option::map_or_else

The following call:

byte_builder.option_or_else(value, none_call, some_call);

equivalent to the construction:

if let Some(value) = value {
   some_call(byte_builder, value)
} else {
   none_call(byte_builder)
}

pub fn finalize(self) -> ByteArray<T>

Finalize the buffer and return a fixed ByteArray of T

pub fn finalize_as_vec(self) -> Vec<u8>

Finalize the buffer and return a fixed ByteArray of T

Trait Implementations

impl<T: Clone> Clone for ByteBuilder<T>

fn clone(&self) -> ByteBuilder<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Default> Default for ByteBuilder<T>

fn default() -> ByteBuilder<T>

Returns the “default value” for a type.

impl<T> From<ByteBuilder<T>> for Vec<u8>

fn from(bb: ByteBuilder<T>) -> Vec<u8>

Converts to this type from the input type.