Struct diny_test::Formatter

pub struct Formatter;

A test format that trivially encodes the primitives as their little endian, in memory byte representations.

Trait Implementations

impl Clone for Formatter

fn clone(&self) -> Formatter

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Formatter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Format for Formatter

type Error = Error

The type of errors that can occur during serialization and deserialization

fn invalid_input_err() -> Self::Error

The error to return when an internal serialization contract has been violated

fn invalid_data_err() -> Self::Error

The error to return when a data contract has been violated

impl FormatDecode for Formatter

type DecodeUnit = Decoder

type DecodeBool = Decoder

type DecodeI8 = Decoder

type DecodeI16 = Decoder

type DecodeI32 = Decoder

type DecodeI64 = Decoder

type DecodeI128 = Decoder

type DecodeU8 = Decoder

type DecodeU16 = Decoder

type DecodeU32 = Decoder

type DecodeU64 = Decoder

type DecodeU128 = Decoder

type DecodeF32 = Decoder

type DecodeF64 = Decoder

type DecodeByteVec = Decoder

type DecodeChar = Decoder

type DecodeString = Decoder

This is supported on crate features std or alloc only.

type DecodeVariantIdx = Decoder

type DecodeSequenceLen = Decoder

impl FormatDeserialize for Formatter

type DeserializeUnit = DeserializeExact<'r, ThisFormat, R, (), Decoder>

type DeserializeBool = DeserializeExact<'r, ThisFormat, R, bool, Decoder>

type DeserializeI8 = DeserializeExact<'r, ThisFormat, R, i8, Decoder>

type DeserializeI16 = DeserializeExact<'r, ThisFormat, R, i16, Decoder>

type DeserializeI32 = DeserializeExact<'r, ThisFormat, R, i32, Decoder>

type DeserializeI64 = DeserializeExact<'r, ThisFormat, R, i64, Decoder>

type DeserializeI128 = DeserializeExact<'r, ThisFormat, R, i128, Decoder>

type DeserializeU8 = DeserializeExact<'r, ThisFormat, R, u8, Decoder>

type DeserializeU16 = DeserializeExact<'r, ThisFormat, R, u16, Decoder>

type DeserializeU32 = DeserializeExact<'r, ThisFormat, R, u32, Decoder>

type DeserializeU64 = DeserializeExact<'r, ThisFormat, R, u64, Decoder>

type DeserializeU128 = DeserializeExact<'r, ThisFormat, R, u128, Decoder>

type DeserializeF32 = DeserializeExact<'r, ThisFormat, R, f32, Decoder>

type DeserializeF64 = DeserializeExact<'r, ThisFormat, R, f64, Decoder>

type DeserializeChar = DeserializeExact<'r, ThisFormat, R, char, Decoder>

type DeserializeString = DeserializeExact<'r, R>

This is supported on crate features std or alloc only.

type DeserializeVariantIdx = DeserializeExact<'r, ThisFormat, R, Data, Decoder>

type DeserializeSequenceLen = DeserializeExact<'r, ThisFormat, R, Data, Decoder>

fn deserialize_unit<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeUnit where
    R: AsyncBufRead + Unpin, 

fn deserialize_bool<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeBool where
    R: AsyncBufRead + Unpin, 

fn deserialize_i8<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeI8 where
    R: AsyncBufRead + Unpin, 

fn deserialize_i16<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeI16 where
    R: AsyncBufRead + Unpin, 

fn deserialize_i32<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeI32 where
    R: AsyncBufRead + Unpin, 

fn deserialize_i64<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeI64 where
    R: AsyncBufRead + Unpin, 

fn deserialize_i128<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeI128 where
    R: AsyncBufRead + Unpin, 

fn deserialize_u8<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeU8 where
    R: AsyncBufRead + Unpin, 

fn deserialize_u16<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeU16 where
    R: AsyncBufRead + Unpin, 

fn deserialize_u32<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeU32 where
    R: AsyncBufRead + Unpin, 

fn deserialize_u64<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeU64 where
    R: AsyncBufRead + Unpin, 

fn deserialize_u128<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeU128 where
    R: AsyncBufRead + Unpin, 

fn deserialize_f32<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeF32 where
    R: AsyncBufRead + Unpin, 

fn deserialize_f64<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeF64 where
    R: AsyncBufRead + Unpin, 

fn deserialize_char<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeChar where
    R: AsyncBufRead + Unpin, 

fn deserialize_string<'r, R>(
    &'r self,
    reader: &'r mut R
) -> Self::DeserializeString where
    R: AsyncBufRead + Unpin, 

This is supported on crate features std or alloc only.

fn deserialize_variant_idx<'r, R>(
    &'r self,
    reader: &'r mut R
) -> Self::DeserializeVariantIdx where
    R: AsyncBufRead + Unpin, 

fn deserialize_sequence_len<'r, R>(
    &'r self,
    reader: &'r mut R
) -> Self::DeserializeSequenceLen where
    R: AsyncBufRead + Unpin, 

impl FormatEncode for Formatter

type EncodeUnit = Encoder

type EncodeBool = Encoder

type EncodeI8 = Encoder

type EncodeI16 = Encoder

type EncodeI32 = Encoder

type EncodeI64 = Encoder

type EncodeI128 = Encoder

type EncodeU8 = Encoder

type EncodeU16 = Encoder

type EncodeU32 = Encoder

type EncodeU64 = Encoder

type EncodeU128 = Encoder

type EncodeF32 = Encoder

type EncodeF64 = Encoder

type EncodeByteSlice = Encoder

type EncodeChar = Encoder

type EncodeStr = Encoder

type EncodeString = Encoder

This is supported on crate features std or alloc only.

type EncodeVariantIdx = Encoder

type EncodeSequenceLen = Encoder

impl FormatSerialize for Formatter

type SerializeUnit = BufferEncoder<'w, ThisFormat, W, (), Encoder>

type SerializeBool = BufferEncoder<'w, ThisFormat, W, bool, Encoder>

type SerializeI8 = BufferEncoder<'w, ThisFormat, W, i8, Encoder>

type SerializeI16 = BufferEncoder<'w, ThisFormat, W, i16, Encoder>

type SerializeI32 = BufferEncoder<'w, ThisFormat, W, i32, Encoder>

type SerializeI64 = BufferEncoder<'w, ThisFormat, W, i64, Encoder>

type SerializeI128 = BufferEncoder<'w, ThisFormat, W, i128, Encoder>

type SerializeU8 = BufferEncoder<'w, ThisFormat, W, u8, Encoder>

type SerializeU16 = BufferEncoder<'w, ThisFormat, W, u16, Encoder>

type SerializeU32 = BufferEncoder<'w, ThisFormat, W, u32, Encoder>

type SerializeU64 = BufferEncoder<'w, ThisFormat, W, u64, Encoder>

type SerializeU128 = BufferEncoder<'w, ThisFormat, W, u128, Encoder>

type SerializeF32 = BufferEncoder<'w, ThisFormat, W, f32, Encoder>

type SerializeF64 = BufferEncoder<'w, ThisFormat, W, f64, Encoder>

type SerializeByteSlice = SerializeAll<'w, W>

type SerializeChar = BufferEncoder<'w, ThisFormat, W, char, Encoder>

type SerializeStr = SerializeAll<'w, W>

type SerializeString = SerializeAll<'w, W>

This is supported on crate features std or alloc only.

type SerializeVariantIdx = BufferEncoder<'w, ThisFormat, W, Data, Encoder>

type SerializeSequenceLen = BufferEncoder<'w, ThisFormat, W, Data, Encoder>

fn serialize_unit<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &()
) -> Self::SerializeUnit where
    W: AsyncWrite + Unpin, 

fn serialize_bool<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &bool
) -> Self::SerializeBool where
    W: AsyncWrite + Unpin, 

fn serialize_i8<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &i8
) -> Self::SerializeI8 where
    W: AsyncWrite + Unpin, 

fn serialize_i16<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &i16
) -> Self::SerializeI16 where
    W: AsyncWrite + Unpin, 

fn serialize_i32<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &i32
) -> Self::SerializeI32 where
    W: AsyncWrite + Unpin, 

fn serialize_i64<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &i64
) -> Self::SerializeI64 where
    W: AsyncWrite + Unpin, 

fn serialize_i128<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &i128
) -> Self::SerializeI128 where
    W: AsyncWrite + Unpin, 

fn serialize_u8<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &u8
) -> Self::SerializeU8 where
    W: AsyncWrite + Unpin, 

fn serialize_u16<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &u16
) -> Self::SerializeU16 where
    W: AsyncWrite + Unpin, 

fn serialize_u32<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &u32
) -> Self::SerializeU32 where
    W: AsyncWrite + Unpin, 

fn serialize_u64<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &u64
) -> Self::SerializeU64 where
    W: AsyncWrite + Unpin, 

fn serialize_u128<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &u128
) -> Self::SerializeU128 where
    W: AsyncWrite + Unpin, 

fn serialize_f32<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &f32
) -> Self::SerializeF32 where
    W: AsyncWrite + Unpin, 

fn serialize_f64<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &f64
) -> Self::SerializeF64 where
    W: AsyncWrite + Unpin, 

fn serialize_byte_slice<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &'w [u8]
) -> Self::SerializeByteSlice where
    W: AsyncWrite + Unpin, 

fn serialize_char<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &char
) -> Self::SerializeChar where
    W: AsyncWrite + Unpin, 

fn serialize_str<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &'w str
) -> Self::SerializeStr where
    W: AsyncWrite + Unpin, 

fn serialize_string<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &'w String
) -> Self::SerializeString where
    W: AsyncWrite + Unpin, 

This is supported on crate features std or alloc only.

fn serialize_variant_idx<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &VariantIdx
) -> Self::SerializeVariantIdx where
    W: AsyncWrite + Unpin, 

fn serialize_sequence_len<'w, W>(
    &'w self,
    writer: &'w mut W,
    data: &SequenceLen
) -> Self::SerializeSequenceLen where
    W: AsyncWrite + Unpin, 

impl Copy for Formatter