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, 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<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 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<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<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<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<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 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 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<'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 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>

source§

impl<'ser, F, T, const N: usize> Serialize<[F; N]> 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 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<str> for &str

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 &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 &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<'ser, F, T> Serialize<Option<F>> for &'ser Option<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, 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<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<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<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 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>

source§

impl<'ser, F, T> Serialize<[F]> for &'ser VecDeque<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<'ser, F, T: ?Sized> Serialize<F> for &&'ser Twhere F: BareFormula + ?Sized, &'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<'ser, 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 &'ser (BH, BI, BJ, BK, BL, BM, BN, BO, BP, BG)where AH: Formula, &'ser BH: Serialize<AH>, AI: Formula, &'ser BI: Serialize<AI>, AJ: Formula, &'ser BJ: Serialize<AJ>, AK: Formula, &'ser BK: Serialize<AK>, AL: Formula, &'ser BL: Serialize<AL>, AM: Formula, &'ser BM: Serialize<AM>, AN: Formula, &'ser BN: Serialize<AN>, AO: Formula, &'ser BO: Serialize<AO>, AP: Formula, &'ser BP: Serialize<AP>, AG: Formula + ?Sized, &'ser BG: Serialize<AG>, BG: ?Sized,

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<'ser, AO, AP, AN, BO, BP, BN> Serialize<(AO, AP, AN)> for &'ser (BO, BP, BN)where AO: Formula, &'ser BO: Serialize<AO>, AP: Formula, &'ser BP: Serialize<AP>, AN: Formula + ?Sized, &'ser BN: Serialize<AN>, BN: ?Sized,

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<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<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, 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<'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 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 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 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 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<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<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 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 Serialize<Bytes> for &str

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 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<'ser, AN, AO, AP, AM, BN, BO, BP, BM> Serialize<(AN, AO, AP, AM)> for &'ser (BN, BO, BP, BM)where AN: Formula, &'ser BN: Serialize<AN>, AO: Formula, &'ser BO: Serialize<AO>, AP: Formula, &'ser BP: Serialize<AP>, AM: Formula + ?Sized, &'ser BM: Serialize<AM>, BM: ?Sized,

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<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<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, 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<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<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<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<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 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 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 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<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<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<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<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<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 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 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<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 Serialize<Bytes> 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<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<'ser, 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 &'ser (BJ, BK, BL, BM, BN, BO, BP, BI)where AJ: Formula, &'ser BJ: Serialize<AJ>, AK: Formula, &'ser BK: Serialize<AK>, AL: Formula, &'ser BL: Serialize<AL>, AM: Formula, &'ser BM: Serialize<AM>, AN: Formula, &'ser BN: Serialize<AN>, AO: Formula, &'ser BO: Serialize<AO>, AP: Formula, &'ser BP: Serialize<AP>, AI: Formula + ?Sized, &'ser BI: Serialize<AI>, BI: ?Sized,

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<'ser, AK, AL, AM, AN, AO, AP, AJ, BK, BL, BM, BN, BO, BP, BJ> Serialize<(AK, AL, AM, AN, AO, AP, AJ)> for &'ser (BK, BL, BM, BN, BO, BP, BJ)where AK: Formula, &'ser BK: Serialize<AK>, AL: Formula, &'ser BL: Serialize<AL>, AM: Formula, &'ser BM: Serialize<AM>, AN: Formula, &'ser BN: Serialize<AN>, AO: Formula, &'ser BO: Serialize<AO>, AP: Formula, &'ser BP: Serialize<AP>, AJ: Formula + ?Sized, &'ser BJ: Serialize<AJ>, BJ: ?Sized,

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<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 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<'ser, AP, BP> Serialize<(AP,)> for &'ser (BP,)where AP: Formula + ?Sized, &'ser BP: Serialize<AP>, BP: ?Sized,

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

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<'ser, 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 &'ser (BC, BD, BE, BF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BB)where AC: Formula, &'ser BC: Serialize<AC>, AD: Formula, &'ser BD: Serialize<AD>, AE: Formula, &'ser BE: Serialize<AE>, AF: Formula, &'ser BF: Serialize<AF>, AG: Formula, &'ser BG: Serialize<AG>, AH: Formula, &'ser BH: Serialize<AH>, AI: Formula, &'ser BI: Serialize<AI>, AJ: Formula, &'ser BJ: Serialize<AJ>, AK: Formula, &'ser BK: Serialize<AK>, AL: Formula, &'ser BL: Serialize<AL>, AM: Formula, &'ser BM: Serialize<AM>, AN: Formula, &'ser BN: Serialize<AN>, AO: Formula, &'ser BO: Serialize<AO>, AP: Formula, &'ser BP: Serialize<AP>, AB: Formula + ?Sized, &'ser BB: Serialize<AB>, BB: ?Sized,

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<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<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 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 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<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<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 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 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<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 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 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<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<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 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 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<'ser, AP, AO, BP, BO> Serialize<(AP, AO)> for &'ser (BP, BO)where AP: Formula, &'ser BP: Serialize<AP>, AO: Formula + ?Sized, &'ser BO: Serialize<AO>, BO: ?Sized,

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 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 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<'ser, 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 &'ser (BI, BJ, BK, BL, BM, BN, BO, BP, BH)where AI: Formula, &'ser BI: Serialize<AI>, AJ: Formula, &'ser BJ: Serialize<AJ>, AK: Formula, &'ser BK: Serialize<AK>, AL: Formula, &'ser BL: Serialize<AL>, AM: Formula, &'ser BM: Serialize<AM>, AN: Formula, &'ser BN: Serialize<AN>, AO: Formula, &'ser BO: Serialize<AO>, AP: Formula, &'ser BP: Serialize<AP>, AH: Formula + ?Sized, &'ser BH: Serialize<AH>, BH: ?Sized,

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, AL, AM, AN, AO, AP, AK, BL, BM, BN, BO, BP, BK> Serialize<(AL, AM, AN, AO, AP, AK)> for &'ser (BL, BM, BN, BO, BP, BK)where AL: Formula, &'ser BL: Serialize<AL>, AM: Formula, &'ser BM: Serialize<AM>, AN: Formula, &'ser BN: Serialize<AN>, AO: Formula, &'ser BO: Serialize<AO>, AP: Formula, &'ser BP: Serialize<AP>, AK: Formula + ?Sized, &'ser BK: Serialize<AK>, BK: ?Sized,

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 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 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<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<'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<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 &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, 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 &'ser (BE, BF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BD)where AE: Formula, &'ser BE: Serialize<AE>, AF: Formula, &'ser BF: Serialize<AF>, AG: Formula, &'ser BG: Serialize<AG>, AH: Formula, &'ser BH: Serialize<AH>, AI: Formula, &'ser BI: Serialize<AI>, AJ: Formula, &'ser BJ: Serialize<AJ>, AK: Formula, &'ser BK: Serialize<AK>, AL: Formula, &'ser BL: Serialize<AL>, AM: Formula, &'ser BM: Serialize<AM>, AN: Formula, &'ser BN: Serialize<AN>, AO: Formula, &'ser BO: Serialize<AO>, AP: Formula, &'ser BP: Serialize<AP>, AD: Formula + ?Sized, &'ser BD: Serialize<AD>, BD: ?Sized,

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 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<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 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 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<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<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<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<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<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<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<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<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 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 &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<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<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<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 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<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<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<'ser, 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 &'ser (BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BF)where AG: Formula, &'ser BG: Serialize<AG>, AH: Formula, &'ser BH: Serialize<AH>, AI: Formula, &'ser BI: Serialize<AI>, AJ: Formula, &'ser BJ: Serialize<AJ>, AK: Formula, &'ser BK: Serialize<AK>, AL: Formula, &'ser BL: Serialize<AL>, AM: Formula, &'ser BM: Serialize<AM>, AN: Formula, &'ser BN: Serialize<AN>, AO: Formula, &'ser BO: Serialize<AO>, AP: Formula, &'ser BP: Serialize<AP>, AF: Formula + ?Sized, &'ser BF: Serialize<AF>, BF: ?Sized,

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<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<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<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<'ser, AM, AN, AO, AP, AL, BM, BN, BO, BP, BL> Serialize<(AM, AN, AO, AP, AL)> for &'ser (BM, BN, BO, BP, BL)where AM: Formula, &'ser BM: Serialize<AM>, AN: Formula, &'ser BN: Serialize<AN>, AO: Formula, &'ser BO: Serialize<AO>, AP: Formula, &'ser BP: Serialize<AP>, AL: Formula + ?Sized, &'ser BL: Serialize<AL>, BL: ?Sized,

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, 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 &'ser (BF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BE)where AF: Formula, &'ser BF: Serialize<AF>, AG: Formula, &'ser BG: Serialize<AG>, AH: Formula, &'ser BH: Serialize<AH>, AI: Formula, &'ser BI: Serialize<AI>, AJ: Formula, &'ser BJ: Serialize<AJ>, AK: Formula, &'ser BK: Serialize<AK>, AL: Formula, &'ser BL: Serialize<AL>, AM: Formula, &'ser BM: Serialize<AM>, AN: Formula, &'ser BN: Serialize<AN>, AO: Formula, &'ser BO: Serialize<AO>, AP: Formula, &'ser BP: Serialize<AP>, AE: Formula + ?Sized, &'ser BE: Serialize<AE>, BE: ?Sized,

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<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 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<Bytes> 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<'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 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 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<'ser, 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 &'ser (BD, BE, BF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BC)where AD: Formula, &'ser BD: Serialize<AD>, AE: Formula, &'ser BE: Serialize<AE>, AF: Formula, &'ser BF: Serialize<AF>, AG: Formula, &'ser BG: Serialize<AG>, AH: Formula, &'ser BH: Serialize<AH>, AI: Formula, &'ser BI: Serialize<AI>, AJ: Formula, &'ser BJ: Serialize<AJ>, AK: Formula, &'ser BK: Serialize<AK>, AL: Formula, &'ser BL: Serialize<AL>, AM: Formula, &'ser BM: Serialize<AM>, AN: Formula, &'ser BN: Serialize<AN>, AO: Formula, &'ser BO: Serialize<AO>, AP: Formula, &'ser BP: Serialize<AP>, AC: Formula + ?Sized, &'ser BC: Serialize<AC>, BC: ?Sized,

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 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<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<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<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<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<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<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<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<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<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>

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,