Trait alkahest::Serialize

source ·
pub trait Serialize<F: Formula + ?Sized> {
    // Required methods
    fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>
       where Self: Sized,
             B: Buffer;
    fn size_hint(&self) -> Option<Sizes>;
}
Expand description

Trait for types that can be serialized into raw bytes with specified F: Formula.

Implementations must write data according to the formula. Doing otherwise may result in errors during deserialization. Where errors may be both failures to deserialize and incorrect deserialized values.

Examples


struct ThreeBytes;

impl Formula for ThreeBytes {
    const MAX_STACK_SIZE: Option<usize> = Some(3);
    const EXACT_SIZE: bool = true;
    const HEAPLESS: bool = true;
}

struct Qwe;

impl Serialize<ThreeBytes> for Qwe {
    fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>
    where
        Self: Sized,
        B: Buffer,
    {
        write_bytes(b"qwe", sizes, buffer)
    }

    fn size_hint(&self) -> Option<Sizes> {
        Some(Sizes::with_stack(3))
    }
}

Required Methods§

source

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where Self: Sized, B: Buffer,

Serializes self into the given buffer. heap specifies the size of the buffer’s heap occupied prior to this call.

Errors

Returns error if buffer write fails.

source

fn size_hint(&self) -> Option<Sizes>

Returns heap and stack sizes required to serialize self. If some sizes are returned they must be exact.

This function may return none conservatively.

Returning incorrect sizes may cause panics during implementation or broken data.

Implementations on Foreign Types§

source§

impl<F, T> Serialize<[F]> for VecDeque<T>where F: Formula, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AD, BE, BF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BD> Serialize<(AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AD)> for (BE, BF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BD)where AE: Formula, BE: Serialize<AE>, AF: Formula, BF: Serialize<AF>, AG: Formula, BG: Serialize<AG>, AH: Formula, BH: Serialize<AH>, AI: Formula, BI: Serialize<AI>, AJ: Formula, BJ: Serialize<AJ>, AK: Formula, BK: Serialize<AK>, AL: Formula, BL: Serialize<AL>, AM: Formula, BM: Serialize<AM>, AN: Formula, BN: Serialize<AN>, AO: Formula, BO: Serialize<AO>, AP: Formula, BP: Serialize<AP>, AD: Formula + ?Sized, BD: Serialize<AD>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, T> Serialize<[F]> for RangeInclusive<T>where F: Formula, T: Serialize<F>, RangeInclusive<T>: Iterator<Item = T>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, T> Serialize<[F]> for Fuse<I>where F: Formula, I: Iterator<Item = T>, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<i128> for i32

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<u32> for u16

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<Bytes> for &VecDeque<u8>

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<i128> for i64

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, T, P> Serialize<[F]> for FilterMap<I, P>where F: Formula, I: Iterator, P: FnMut(I::Item) -> Option<T>, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, T, P> Serialize<[F]> for OnceWith<P>where F: Formula, P: FnOnce() -> T, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<FixedIsize> for &isize

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, T> Serialize<[F]> for Take<I>where F: Formula, I: Iterator<Item = T>, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, T> Serialize<Option<F>> for Option<T>where F: Formula, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<str> for &String

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AB, BC, BD, BE, BF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BB> Serialize<(AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AB)> for (BC, BD, BE, BF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BB)where AC: Formula, BC: Serialize<AC>, AD: Formula, BD: Serialize<AD>, AE: Formula, BE: Serialize<AE>, AF: Formula, BF: Serialize<AF>, AG: Formula, BG: Serialize<AG>, AH: Formula, BH: Serialize<AH>, AI: Formula, BI: Serialize<AI>, AJ: Formula, BJ: Serialize<AJ>, AK: Formula, BK: Serialize<AK>, AL: Formula, BL: Serialize<AL>, AM: Formula, BM: Serialize<AM>, AN: Formula, BN: Serialize<AN>, AO: Formula, BO: Serialize<AO>, AP: Formula, BP: Serialize<AP>, AB: Formula + ?Sized, BB: Serialize<AB>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, P, T> Serialize<[F]> for SkipWhile<I, P>where F: Formula, I: Iterator<Item = T>, P: FnMut(&T) -> bool, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<i8> for i8

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AP, AO, BP, BO> Serialize<(AP, AO)> for (BP, BO)where AP: Formula, BP: Serialize<AP>, AO: Formula + ?Sized, BO: Serialize<AO>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<f32> for f32

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, T> Serialize<[(FixedUsize, F)]> for Enumerate<I>where F: Formula, I: Iterator<Item = T>, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<i16> for i8

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<u128> for u8

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<u8> for u8

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<bool> for bool

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where Self: Sized, B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, X, Y, T> Serialize<[F]> for Chain<X, Y>where F: Formula, X: Iterator<Item = T>, Y: Iterator<Item = T>, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, T, P> Serialize<[F]> for Successors<T, P>where F: Formula, P: FnMut(&T) -> Option<T>, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<i64> for i32

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<Bytes> for Vec<u8>

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, T, const N: usize> Serialize<[F]> for [T; N]where F: Formula, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, T, P> Serialize<[F]> for Filter<I, P>where F: Formula, I: Iterator<Item = T>, P: FnMut(&T) -> bool, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, T> Serialize<[F]> for Flatten<I>where F: Formula, I: Iterator, I::Item: IntoIterator<Item = T>, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<u32> for u32

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<FixedIsize> for isize

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, T> Serialize<[F]> for Vec<T>where F: Formula, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<'ser, F, T, const N: usize> Serialize<[F]> for &'ser [T; N]where F: Formula, &'ser T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, T, P> Serialize<[F]> for Map<I, P>where F: Formula, I: Iterator, P: FnMut(I::Item) -> T, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AM, AN, AO, AP, AL, BM, BN, BO, BP, BL> Serialize<(AM, AN, AO, AP, AL)> for (BM, BN, BO, BP, BL)where AM: Formula, BM: Serialize<AM>, AN: Formula, BN: Serialize<AN>, AO: Formula, BO: Serialize<AO>, AP: Formula, BP: Serialize<AP>, AL: Formula + ?Sized, BL: Serialize<AL>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<i32> for i16

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<f64> for f64

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<FX, FY, X, Y> Serialize<[(FX, FY)]> for Zip<X, Y>where FX: Formula, FY: Formula, X: Iterator, Y: Iterator, X::Item: Serialize<FX>, Y::Item: Serialize<FY>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<i64> for i64

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AO, AP, AN, BO, BP, BN> Serialize<(AO, AP, AN)> for (BO, BP, BN)where AO: Formula, BO: Serialize<AO>, AP: Formula, BP: Serialize<AP>, AN: Formula + ?Sized, BN: Serialize<AN>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AL, AM, AN, AO, AP, AK, BL, BM, BN, BO, BP, BK> Serialize<(AL, AM, AN, AO, AP, AK)> for (BL, BM, BN, BO, BP, BK)where AL: Formula, BL: Serialize<AL>, AM: Formula, BM: Serialize<AM>, AN: Formula, BN: Serialize<AN>, AO: Formula, BO: Serialize<AO>, AP: Formula, BP: Serialize<AP>, AK: Formula + ?Sized, BK: Serialize<AK>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<'ser, F, T> Serialize<[F]> for &'ser Vec<T>where F: Formula, &'ser T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, T> Serialize<[F]> for Skip<I>where F: Formula, I: Iterator<Item = T>, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<Bytes> for &Vec<u8>

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AP, BP> Serialize<(AP,)> for (BP,)where AP: Formula + ?Sized, BP: Serialize<AP>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, T> Serialize<[F]> for StepBy<I>where F: Formula, I: Iterator<Item = T>, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AH, AI, AJ, AK, AL, AM, AN, AO, AP, AG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BG> Serialize<(AH, AI, AJ, AK, AL, AM, AN, AO, AP, AG)> for (BH, BI, BJ, BK, BL, BM, BN, BO, BP, BG)where AH: Formula, BH: Serialize<AH>, AI: Formula, BI: Serialize<AI>, AJ: Formula, BJ: Serialize<AJ>, AK: Formula, BK: Serialize<AK>, AL: Formula, BL: Serialize<AL>, AM: Formula, BM: Serialize<AM>, AN: Formula, BN: Serialize<AN>, AO: Formula, BO: Serialize<AO>, AP: Formula, BP: Serialize<AP>, AG: Formula + ?Sized, BG: Serialize<AG>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, St, P, T> Serialize<[F]> for Scan<I, St, P>where F: Formula, I: Iterator, P: FnMut(&mut St, I::Item) -> Option<T>, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<u128> for u16

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, T> Serialize<[F]> for Range<T>where F: Formula, T: Serialize<F>, Range<T>: Iterator<Item = T>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, P, T> Serialize<[F]> for FromFn<P>where F: Formula, P: FnMut() -> Option<T>, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<u16> for u16

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<u128> for u64

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<'a, F, I, T> Serialize<[F]> for Cloned<I>where F: Formula, I: Iterator<Item = &'a T>, T: Clone + Serialize<F> + 'a,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, T, X> Serialize<[F]> for Inspect<I, X>where F: Formula, I: Iterator<Item = T>, T: Serialize<F>, X: FnMut(&T),

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<u64> for u64

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AK, AL, AM, AN, AO, AP, AJ, BK, BL, BM, BN, BO, BP, BJ> Serialize<(AK, AL, AM, AN, AO, AP, AJ)> for (BK, BL, BM, BN, BO, BP, BJ)where AK: Formula, BK: Serialize<AK>, AL: Formula, BL: Serialize<AL>, AM: Formula, BM: Serialize<AM>, AN: Formula, BN: Serialize<AN>, AO: Formula, BO: Serialize<AO>, AP: Formula, BP: Serialize<AP>, AJ: Formula + ?Sized, BJ: Serialize<AJ>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<u32> for u8

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<i64> for i16

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, T> Serialize<F> for &Twhere F: BareFormula + ?Sized, T: SerializeRef<F> + ?Sized,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where Self: Sized, B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<u128> for u128

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, T, P> Serialize<[F]> for MapWhile<I, P>where F: Formula, I: Iterator, P: FnMut(I::Item) -> Option<T>, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<i128> for i128

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<'ser, F, T> Serialize<[F]> for &'ser [T]where F: Formula, &'ser T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where Self: Sized, B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, T> Serialize<[F]> for Empty<T>where F: Formula, T: Copy + Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<u64> for u8

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, T> Serialize<[F]> for Peekable<I>where F: Formula, I: Iterator<Item = T>, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<str> for String

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<u64> for u32

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, X, U, T> Serialize<[F]> for FlatMap<I, U, X>where F: Formula, I: Iterator, X: FnMut(I::Item) -> U, U: IntoIterator<Item = T>, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<FixedUsize> for &usize

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<bool> for &bool

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<i32> for i32

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, T> Serialize<[F]> for Once<T>where F: Formula, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, P, T> Serialize<[F]> for TakeWhile<I, P>where F: Formula, I: Iterator<Item = T>, P: FnMut(&T) -> bool, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<f64> for f32

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<i64> for i8

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<u16> for u8

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<i32> for i8

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<i128> for i16

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AI, AJ, AK, AL, AM, AN, AO, AP, AH, BI, BJ, BK, BL, BM, BN, BO, BP, BH> Serialize<(AI, AJ, AK, AL, AM, AN, AO, AP, AH)> for (BI, BJ, BK, BL, BM, BN, BO, BP, BH)where AI: Formula, BI: Serialize<AI>, AJ: Formula, BJ: Serialize<AJ>, AK: Formula, BK: Serialize<AK>, AL: Formula, BL: Serialize<AL>, AM: Formula, BM: Serialize<AM>, AN: Formula, BN: Serialize<AN>, AO: Formula, BO: Serialize<AO>, AP: Formula, BP: Serialize<AP>, AH: Formula + ?Sized, BH: Serialize<AH>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<()> for ()

source§

fn serialize<B>(self, _sizes: &mut Sizes, _buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AJ, AK, AL, AM, AN, AO, AP, AI, BJ, BK, BL, BM, BN, BO, BP, BI> Serialize<(AJ, AK, AL, AM, AN, AO, AP, AI)> for (BJ, BK, BL, BM, BN, BO, BP, BI)where AJ: Formula, BJ: Serialize<AJ>, AK: Formula, BK: Serialize<AK>, AL: Formula, BL: Serialize<AL>, AM: Formula, BM: Serialize<AM>, AN: Formula, BN: Serialize<AN>, AO: Formula, BO: Serialize<AO>, AP: Formula, BP: Serialize<AP>, AI: Formula + ?Sized, BI: Serialize<AI>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BF> Serialize<(AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AF)> for (BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BF)where AG: Formula, BG: Serialize<AG>, AH: Formula, BH: Serialize<AH>, AI: Formula, BI: Serialize<AI>, AJ: Formula, BJ: Serialize<AJ>, AK: Formula, BK: Serialize<AK>, AL: Formula, BL: Serialize<AL>, AM: Formula, BM: Serialize<AM>, AN: Formula, BN: Serialize<AN>, AO: Formula, BO: Serialize<AO>, AP: Formula, BP: Serialize<AP>, AF: Formula + ?Sized, BF: Serialize<AF>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<u64> for u16

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<u128> for u32

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<'a, F, I, T> Serialize<[F]> for Copied<I>where F: Formula, I: Iterator<Item = &'a T>, T: Copy + Serialize<F> + 'a,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<i128> for i8

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AC, BD, BE, BF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BC> Serialize<(AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AC)> for (BD, BE, BF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BC)where AD: Formula, BD: Serialize<AD>, AE: Formula, BE: Serialize<AE>, AF: Formula, BF: Serialize<AF>, AG: Formula, BG: Serialize<AG>, AH: Formula, BH: Serialize<AH>, AI: Formula, BI: Serialize<AI>, AJ: Formula, BJ: Serialize<AJ>, AK: Formula, BK: Serialize<AK>, AL: Formula, BL: Serialize<AL>, AM: Formula, BM: Serialize<AM>, AN: Formula, BN: Serialize<AN>, AO: Formula, BO: Serialize<AO>, AP: Formula, BP: Serialize<AP>, AC: Formula + ?Sized, BC: Serialize<AC>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, I, T> Serialize<[F]> for Rev<I>where F: Formula, I: DoubleEndedIterator<Item = T>, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<FixedUsize> for usize

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BA> Serialize<(AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AA)> for (BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BA)where AB: Formula, BB: Serialize<AB>, AC: Formula, BC: Serialize<AC>, AD: Formula, BD: Serialize<AD>, AE: Formula, BE: Serialize<AE>, AF: Formula, BF: Serialize<AF>, AG: Formula, BG: Serialize<AG>, AH: Formula, BH: Serialize<AH>, AI: Formula, BI: Serialize<AI>, AJ: Formula, BJ: Serialize<AJ>, AK: Formula, BK: Serialize<AK>, AL: Formula, BL: Serialize<AL>, AM: Formula, BM: Serialize<AM>, AN: Formula, BN: Serialize<AN>, AO: Formula, BO: Serialize<AO>, AP: Formula, BP: Serialize<AP>, AA: Formula + ?Sized, BA: Serialize<AA>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<F, T, const N: usize> Serialize<[F; N]> for [T; N]where F: Formula, T: Serialize<F>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AE, BF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BE> Serialize<(AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AE)> for (BF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BE)where AF: Formula, BF: Serialize<AF>, AG: Formula, BG: Serialize<AG>, AH: Formula, BH: Serialize<AH>, AI: Formula, BI: Serialize<AI>, AJ: Formula, BJ: Serialize<AJ>, AK: Formula, BK: Serialize<AK>, AL: Formula, BL: Serialize<AL>, AM: Formula, BM: Serialize<AM>, AN: Formula, BN: Serialize<AN>, AO: Formula, BO: Serialize<AO>, AP: Formula, BP: Serialize<AP>, AE: Formula + ?Sized, BE: Serialize<AE>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl<AN, AO, AP, AM, BN, BO, BP, BM> Serialize<(AN, AO, AP, AM)> for (BN, BO, BP, BM)where AN: Formula, BN: Serialize<AN>, AO: Formula, BO: Serialize<AO>, AP: Formula, BP: Serialize<AP>, AM: Formula + ?Sized, BM: Serialize<AM>,

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<Bytes> for VecDeque<u8>

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

source§

impl Serialize<i16> for i16

source§

fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where B: Buffer,

source§

fn size_hint(&self) -> Option<Sizes>

Implementors§

source§

impl Serialize<FixedIsize> for &FixedIsize

source§

impl Serialize<FixedIsize> for FixedIsize

source§

impl Serialize<FixedUsize> for &FixedUsize

source§

impl Serialize<FixedUsize> for FixedUsize

source§

impl<F, T> Serialize<VecDeque<F, Global>> for Twhere F: Formula, T: Serialize<[F]>,

source§

impl<F, T> Serialize<Vec<F, Global>> for Twhere F: Formula, T: Serialize<[F]>,

source§

impl<F, T> Serialize<As<F>> for Twhere F: BareFormula + ?Sized, T: Serialize<F>,

source§

impl<F, T> Serialize<Ref<F>> for Twhere F: BareFormula + ?Sized, T: Serialize<F>,

source§

impl<F, T, I> Serialize<[F]> for SerIter<I>where F: Formula, I: Iterator<Item = T>, T: Serialize<F>,

source§

impl<T> Serialize<String> for Twhere T: Serialize<str>,

source§

impl<T> Serialize<Vlq> for Twhere T: VlqType,