Trait Encoder 

pub trait Encoder<E, T: ?Sized> {
    // Required methods
    fn encode<B: BufMut + ?Sized>(
        tag: u32,
        value: &T,
        buf: &mut B,
        tw: &mut TagWriter,
    );
    fn prepend_encode<B: ReverseBuf + ?Sized>(
        tag: u32,
        value: &T,
        buf: &mut B,
        tw: &mut TagRevWriter,
    );
    fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize;
}

The core trait for encoding bilrost data.

Required Methods

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

Encodes the a field with the given tag and value.

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

Prepends the encoding of the field with the given tag and value.

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

Returns the encoded length of the field, including the key.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Encoder<PlainBytes, Vec<Vec<u8>>> for ()

where (): Encoder<Unpacked<PlainBytes>, Vec<Vec<u8>>>,

fn encode<B: BufMut + ?Sized>( tag: u32, value: &Vec<Vec<u8>>, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &Vec<Vec<u8>>, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len( tag: u32, value: &Vec<Vec<u8>>, tm: &mut impl TagMeasurer, ) -> usize

impl<'a> Encoder<PlainBytes, Vec<&'a [u8]>> for ()

where (): Encoder<Unpacked<PlainBytes>, Vec<&'a [u8]>>,

fn encode<B: BufMut + ?Sized>( tag: u32, value: &Vec<&'a [u8]>, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &Vec<&'a [u8]>, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len( tag: u32, value: &Vec<&'a [u8]>, tm: &mut impl TagMeasurer, ) -> usize

impl<'a> Encoder<PlainBytes, Vec<Cow<'a, [u8]>>> for ()

where (): Encoder<Unpacked<PlainBytes>, Vec<Cow<'a, [u8]>>>,

fn encode<B: BufMut + ?Sized>( tag: u32, value: &Vec<Cow<'a, [u8]>>, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &Vec<Cow<'a, [u8]>>, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len( tag: u32, value: &Vec<Cow<'a, [u8]>>, tm: &mut impl TagMeasurer, ) -> usize

impl<'a, T> Encoder<GeneralGeneric<PREFER_UNPACKED>, Cow<'a, [T]>> for ()

where (): Encoder<Unpacked, Cow<'a, [T]>>, T: Clone,

fn encode<B: BufMut + ?Sized>( tag: u32, value: &Cow<'a, [T]>, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &Cow<'a, [T]>, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len( tag: u32, value: &Cow<'a, [T]>, tm: &mut impl TagMeasurer, ) -> usize

impl<'a, const N: usize> Encoder<PlainBytes, Vec<&'a [u8; N]>> for ()

where (): Encoder<Unpacked<PlainBytes>, Vec<&'a [u8; N]>>,

fn encode<B: BufMut + ?Sized>( tag: u32, value: &Vec<&'a [u8; N]>, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &Vec<&'a [u8; N]>, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len( tag: u32, value: &Vec<&'a [u8; N]>, tm: &mut impl TagMeasurer, ) -> usize

impl<C, T, E> Encoder<Packed<E>, C> for ()

where C: Collection<Item = T>, (): EmptyState<(), C> + ForOverwrite<E, T> + ValueEncoder<E, T> + ValueEncoder<Packed<E>, C>,

ValueEncoder for packed repeated encodings lets this value type nest.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &C, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &C, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &C, tm: &mut impl TagMeasurer) -> usize

impl<C, T, E> Encoder<Unpacked<E>, C> for ()

where C: Collection<Item = T>, (): EmptyState<(), C> + ForOverwrite<E, T> + ValueEncoder<E, T>,

Unpacked encodes vecs as repeated fields and in relaxed decoding mode will accept both packed and un-packed encodings.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &C, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &C, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &C, tm: &mut impl TagMeasurer) -> usize

impl<T> Encoder<Fixed, T> for ()

where (): EmptyState<Fixed, T> + ValueEncoder<Fixed, T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T> Encoder<GeneralGeneric<PREFER_UNPACKED>, BTreeSet<T>> for ()

where (): Encoder<Unpacked, BTreeSet<T>>,

fn encode<B: BufMut + ?Sized>( tag: u32, value: &BTreeSet<T>, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &BTreeSet<T>, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len( tag: u32, value: &BTreeSet<T>, tm: &mut impl TagMeasurer, ) -> usize

impl<T> Encoder<GeneralGeneric<PREFER_UNPACKED>, Vec<T>> for ()

where (): Encoder<Unpacked, Vec<T>>,

fn encode<B: BufMut + ?Sized>( tag: u32, value: &Vec<T>, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &Vec<T>, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &Vec<T>, tm: &mut impl TagMeasurer) -> usize

impl<T> Encoder<PlainBytes, T> for ()

where (): EmptyState<PlainBytes, T> + ValueEncoder<PlainBytes, T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T> Encoder<Varint, T> for ()

where (): EmptyState<Varint, T> + ValueEncoder<Varint, T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T, Ae> Encoder<(Ae,), T> for ()

where (): EmptyState<(Ae,), T> + ValueEncoder<(Ae,), T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T, Ae, Be> Encoder<(Ae, Be), T> for ()

where (): EmptyState<(Ae, Be), T> + ValueEncoder<(Ae, Be), T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T, Ae, Be, Ce> Encoder<(Ae, Be, Ce), T> for ()

where (): EmptyState<(Ae, Be, Ce), T> + ValueEncoder<(Ae, Be, Ce), T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T, Ae, Be, Ce, De> Encoder<(Ae, Be, Ce, De), T> for ()

where (): EmptyState<(Ae, Be, Ce, De), T> + ValueEncoder<(Ae, Be, Ce, De), T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T, Ae, Be, Ce, De, Ee> Encoder<(Ae, Be, Ce, De, Ee), T> for ()

where (): EmptyState<(Ae, Be, Ce, De, Ee), T> + ValueEncoder<(Ae, Be, Ce, De, Ee), T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T, Ae, Be, Ce, De, Ee, Fe> Encoder<(Ae, Be, Ce, De, Ee, Fe), T> for ()

where (): EmptyState<(Ae, Be, Ce, De, Ee, Fe), T> + ValueEncoder<(Ae, Be, Ce, De, Ee, Fe), T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T, Ae, Be, Ce, De, Ee, Fe, Ge> Encoder<(Ae, Be, Ce, De, Ee, Fe, Ge), T> for ()

where (): EmptyState<(Ae, Be, Ce, De, Ee, Fe, Ge), T> + ValueEncoder<(Ae, Be, Ce, De, Ee, Fe, Ge), T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T, Ae, Be, Ce, De, Ee, Fe, Ge, He> Encoder<(Ae, Be, Ce, De, Ee, Fe, Ge, He), T> for ()

where (): EmptyState<(Ae, Be, Ce, De, Ee, Fe, Ge, He), T> + ValueEncoder<(Ae, Be, Ce, De, Ee, Fe, Ge, He), T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T, Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie> Encoder<(Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie), T> for ()

where (): EmptyState<(Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie), T> + ValueEncoder<(Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie), T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T, Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie, Je> Encoder<(Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie, Je), T> for ()

where (): EmptyState<(Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie, Je), T> + ValueEncoder<(Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie, Je), T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T, Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie, Je, Ke> Encoder<(Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie, Je, Ke), T> for ()

where (): EmptyState<(Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie, Je, Ke), T> + ValueEncoder<(Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie, Je, Ke), T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T, Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie, Je, Ke, Le> Encoder<(Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie, Je, Ke, Le), T> for ()

where (): EmptyState<(Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie, Je, Ke, Le), T> + ValueEncoder<(Ae, Be, Ce, De, Ee, Fe, Ge, He, Ie, Je, Ke, Le), T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T, E> Encoder<Packed<E>, [T]> for ()

where (): ValueEncoder<E, T>,

fn encode<B: BufMut + ?Sized>( tag: u32, value: &[T], buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &[T], buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &[T], tm: &mut impl TagMeasurer) -> usize

impl<T, E> Encoder<Unpacked<E>, [T]> for ()

where (): ValueEncoder<E, T>,

Unpacked encodes slices the same way as arrays. This implementation always uses the natural emptiness and item iteration of the slice, since implementing EmptyState for the unsized [T] isn’t practical.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &[T], buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &[T], buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &[T], tm: &mut impl TagMeasurer) -> usize

impl<T, E> Encoder<E, Option<T>> for ()

where (): ValueEncoder<E, T> + ForOverwrite<E, T>,

fn encode<B: BufMut + ?Sized>( tag: u32, value: &Option<T>, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &Option<T>, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &Option<T>, tm: &mut impl TagMeasurer) -> usize

impl<T, KE, VE> Encoder<Map<KE, VE>, T> for ()

where (): EmptyState<Map<KE, VE>, T> + ValueEncoder<Map<KE, VE>, T> + EmptyState<(), T>, T: Mapping,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

impl<T, S> Encoder<GeneralGeneric<PREFER_UNPACKED>, HashSet<T, S>> for ()

where (): Encoder<Unpacked, HashSet<T, S>>, S: Default + BuildHasher,

fn encode<B: BufMut + ?Sized>( tag: u32, value: &HashSet<T, S>, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &HashSet<T, S>, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len( tag: u32, value: &HashSet<T, S>, tm: &mut impl TagMeasurer, ) -> usize

impl<T, const N: usize, E> Encoder<Packed<E>, [T; N]> for ()

where (): ValueEncoder<E, T> + EmptyState<E, [T; N]>,

fn encode<B: BufMut + ?Sized>( tag: u32, value: &[T; N], buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &[T; N], buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &[T; N], tm: &mut impl TagMeasurer) -> usize

impl<T, const N: usize, E> Encoder<Unpacked<E>, Option<[T; N]>> for ()

where (): ValueEncoder<E, T> + ForOverwrite<E, [T; N]>,

Unpacked encodes arrays as repeated fields if any of the values are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &Option<[T; N]>, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &Option<[T; N]>, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len( tag: u32, value: &Option<[T; N]>, tm: &mut impl TagMeasurer, ) -> usize

impl<T, const N: usize, E> Encoder<Unpacked<E>, [T; N]> for ()

where (): ValueEncoder<E, T> + EmptyState<E, [T; N]>,

Unpacked encodes arrays as repeated fields if any of the values are non-empty, and in relaxed decoding mode will accept both packed and un-packed encodings.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &[T; N], buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &[T; N], buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &[T; N], tm: &mut impl TagMeasurer) -> usize

impl<T, const P: u8> Encoder<GeneralGeneric<P>, T> for ()

where (): EmptyState<GeneralGeneric<P>, T> + ValueEncoder<GeneralGeneric<P>, T>,

Encodes plain values only when they are non-empty.

fn encode<B: BufMut + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagWriter, )

fn prepend_encode<B: ReverseBuf + ?Sized>( tag: u32, value: &T, buf: &mut B, tw: &mut TagRevWriter, )

fn encoded_len(tag: u32, value: &T, tm: &mut impl TagMeasurer) -> usize

Implementors