Trait alkahest::SerializeRef

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

Serialize but for references.

Required Methods

fn serialize<B>(&self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>where 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.

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

impl SerializeRef<u128> for u32

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

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

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

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

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

impl SerializeRef<i32> for i16

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

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

impl SerializeRef<u16> for u8

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

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

impl SerializeRef<i16> for i8

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

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

impl SerializeRef<u128> for u16

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

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

impl<F, T> SerializeRef<Option<F>> for Option<T>where F: Formula, for<'ser> &'ser T: Serialize<F>,

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

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

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

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

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

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

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

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

impl SerializeRef<i16> for i16

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

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

impl SerializeRef<i32> for i8

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

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

impl SerializeRef<u8> for u8

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

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

impl SerializeRef<f64> for f32

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

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

impl SerializeRef<u128> for u128

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

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

impl SerializeRef<i128> for i64

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

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

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

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

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

impl SerializeRef<i128> for i16

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

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

impl SerializeRef<u64> for u16

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

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

impl<F, T> SerializeRef<F> for &Twhere F: Formula + ?Sized, T: ?Sized, for<'a> &'a T: Serialize<F>,

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

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

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

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

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

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

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

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

impl SerializeRef<()> for ()

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

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

impl SerializeRef<u64> for u8

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

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

impl SerializeRef<u64> for u64

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

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

impl SerializeRef<u16> for u16

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

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

impl SerializeRef<u32> for u32

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

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

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

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

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

impl SerializeRef<u128> for u8

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

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

impl SerializeRef<i64> for i32

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

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

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

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

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

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

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

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

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

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

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

impl SerializeRef<i128> for i8

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

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

impl SerializeRef<i64> for i8

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

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

impl SerializeRef<f32> for f32

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

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

impl SerializeRef<u32> for u16

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

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

impl SerializeRef<u64> for u32

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

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

impl SerializeRef<i32> for i32

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

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

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

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

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

impl SerializeRef<f64> for f64

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

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

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

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

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

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

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

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

impl SerializeRef<i128> for i128

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

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

impl SerializeRef<i64> for i64

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

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

impl SerializeRef<str> for str

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

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

impl SerializeRef<u128> for u64

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

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

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

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

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

impl SerializeRef<u32> for u8

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

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

impl SerializeRef<i128> for i32

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

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

impl SerializeRef<Bytes> for [u8]

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

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

impl SerializeRef<i8> for i8

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

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

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

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

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

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

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

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

impl SerializeRef<i64> for i16

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

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

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

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

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

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

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

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

Implementors