Struct ordcode::Serializer

pub struct Serializer<W, P> { /* fields omitted */ }

serde serializer for binary data format which may preserve lexicographic ordering of values

The data format is customizable: you can choose lexicographic ordering for encoding of primitive types, endianness, encoding of lengths and enum discriminants; please see SerializerParams trait. This crate provides params::AscendingOrder, which is a default parameter set for Serializer which has the property to preserve lexicographic ordering of serialized values. To obtain the descending lexicographic ordering, the resulting byte buffer should be bitwise inverted, e.g. with primitives::invert_buffer()).

Serializer requires access to a double-ended data buffer, which should implement WriteBytes and TailWriteBytes traits. This crate provides a DeWriteBuffer type, which is a wrapper around a user-provided mutable slice to be used as a write buffer.

Serializer does not allocate anything: double-ended buffer should be big enough to contain serialized data. To know required buffer size in advance, please use calc_size with the same SerializerParams. Size calculation is cheap, for fixed-size structures it folds into compile-time constant.

Implementations

impl<W, P> Serializer<W, P> where
    W: TailWriteBytes,
    P: SerializerParams, 

pub fn new(writer: W, params: P) -> Self

pub fn into_writer(self) -> W

Trait Implementations

impl<W> FormatVersion<AscendingOrder> for Serializer<W, AscendingOrder>

pub const VERSION: u32

impl<W> FormatVersion<NativeBinary> for Serializer<W, NativeBinary>

pub const VERSION: u32

impl<W> FormatVersion<PortableBinary> for Serializer<W, PortableBinary>

pub const VERSION: u32

impl<'a, W, P> Serializer for &'a mut Serializer<W, P> where
    W: TailWriteBytes,
    P: SerializerParams, 

type Ok = ()

The output type produced by this Serializer during successful serialization. Most serializers that produce text or binary output should set Ok = () and serialize into an io::Write or buffer contained within the Serializer instance. Serializers that build in-memory data structures may be simplified by using Ok to propagate the data structure around.

type Error = Error

The error type when some error occurs during serialization.

type SerializeSeq = SerializeCompoundSeq<'a, W, P>

Type returned from serialize_seq for serializing the content of the sequence.

type SerializeTuple = SerializeCompound<'a, W, P>

Type returned from serialize_tuple for serializing the content of the tuple.

type SerializeTupleStruct = SerializeCompound<'a, W, P>

Type returned from serialize_tuple_struct for serializing the content of the tuple struct.

type SerializeTupleVariant = SerializeCompound<'a, W, P>

Type returned from serialize_tuple_variant for serializing the content of the tuple variant.

type SerializeMap = SerializeCompoundSeq<'a, W, P>

Type returned from serialize_map for serializing the content of the map.

type SerializeStruct = SerializeCompound<'a, W, P>

Type returned from serialize_struct for serializing the content of the struct.

type SerializeStructVariant = SerializeCompound<'a, W, P>

Type returned from serialize_struct_variant for serializing the content of the struct variant.

pub fn serialize_bool(self, v: bool) -> Result

Serialize a bool value.

pub fn serialize_u8(self, v: u8) -> Result

Serialize a u8 value.

pub fn serialize_u16(self, v: u16) -> Result

Serialize a u16 value.

pub fn serialize_u32(self, v: u32) -> Result

Serialize a u32 value.

pub fn serialize_u64(self, v: u64) -> Result

Serialize a u64 value.

pub fn serialize_i8(self, v: i8) -> Result

Serialize an i8 value.

pub fn serialize_i16(self, v: i16) -> Result

Serialize an i16 value.

pub fn serialize_i32(self, v: i32) -> Result

Serialize an i32 value.

pub fn serialize_i64(self, v: i64) -> Result

Serialize an i64 value.

pub fn serialize_f32(self, v: f32) -> Result

Serialize an f32 value.

pub fn serialize_f64(self, v: f64) -> Result

Serialize an f64 value.

pub fn serialize_u128(self, v: u128) -> Result

Serialize a u128 value.

pub fn serialize_i128(self, v: i128) -> Result

Serialize an i128 value.

pub fn serialize_char(self, v: char) -> Result

Serialize a character.

pub fn serialize_str(self, v: &str) -> Result

Serialize a &str.

pub fn serialize_bytes(self, v: &[u8]) -> Result

Serialize a chunk of raw byte data.

pub fn serialize_none(self) -> Result

Serialize a None value.

pub fn serialize_some<T: ?Sized>(self, value: &T) -> Result where
    T: Serialize, 

Serialize a Some(T) value.

pub fn serialize_unit(self) -> Result

Serialize a () value.

pub fn serialize_unit_struct(self, _name: &'static str) -> Result

Serialize a unit struct like struct Unit or PhantomData<T>.

pub fn serialize_unit_variant(
    self,
    _name: &'static str,
    variant_index: u32,
    _variant: &'static str
) -> Result

Serialize a unit variant like E::A in enum E { A, B }.

pub fn serialize_newtype_struct<T: ?Sized>(
    self,
    _name: &'static str,
    value: &T
) -> Result where
    T: Serialize, 

Serialize a newtype struct like struct Millimeters(u8).

pub fn serialize_newtype_variant<T: ?Sized>(
    self,
    _name: &'static str,
    variant_index: u32,
    _variant: &'static str,
    value: &T
) -> Result where
    T: Serialize, 

Serialize a newtype variant like E::N in enum E { N(u8) }.

pub fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple>

Begin to serialize a statically sized sequence whose length will be known at deserialization time without looking at the serialized data. This call must be followed by zero or more calls to serialize_element, then a call to end.

pub fn serialize_tuple_struct(
    self,
    _name: &'static str,
    _len: usize
) -> Result<Self::SerializeTupleStruct>

Begin to serialize a tuple struct like struct Rgb(u8, u8, u8). This call must be followed by zero or more calls to serialize_field, then a call to end.

pub fn serialize_tuple_variant(
    self,
    _name: &'static str,
    variant_index: u32,
    _variant: &'static str,
    _len: usize
) -> Result<Self::SerializeTupleVariant>

Begin to serialize a tuple variant like E::T in enum E { T(u8, u8) }. This call must be followed by zero or more calls to serialize_field, then a call to end.

pub fn serialize_struct(
    self,
    _name: &'static str,
    _len: usize
) -> Result<Self::SerializeStruct>

Begin to serialize a struct like struct Rgb { r: u8, g: u8, b: u8 }. This call must be followed by zero or more calls to serialize_field, then a call to end.

pub fn serialize_struct_variant(
    self,
    _name: &'static str,
    variant_index: u32,
    _variant: &'static str,
    _len: usize
) -> Result<Self::SerializeStructVariant>

Begin to serialize a struct variant like E::S in enum E { S { r: u8, g: u8, b: u8 } }. This call must be followed by zero or more calls to serialize_field, then a call to end.

pub fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq>

Begin to serialize a variably sized sequence. This call must be followed by zero or more calls to serialize_element, then a call to end.

pub fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap>

Begin to serialize a map. This call must be followed by zero or more calls to serialize_key and serialize_value, then a call to end.

pub fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
    I: IntoIterator,
    <I as IntoIterator>::Item: Serialize, 

Collect an iterator as a sequence.

pub fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
    I: IntoIterator<Item = (K, V)>,
    V: Serialize,
    K: Serialize, 

Collect an iterator as a map.

pub fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error> where
    T: Display + ?Sized, 

Serialize a string produced by an implementation of Display.

pub fn is_human_readable(&self) -> bool

Determine whether Serialize implementations should serialize in human-readable form.