[−][src]Struct ordcode::Serializer
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,
[src]
W: TailWriteBytes,
P: SerializerParams,
pub fn new(writer: W, params: P) -> Self
[src]
pub fn into_writer(self) -> W
[src]
Trait Implementations
impl<W> FormatVersion<AscendingOrder> for Serializer<W, AscendingOrder>
[src]
impl<W> FormatVersion<NativeBinary> for Serializer<W, NativeBinary>
[src]
impl<W> FormatVersion<PortableBinary> for Serializer<W, PortableBinary>
[src]
impl<'a, W, P> Serializer for &'a mut Serializer<W, P> where
W: TailWriteBytes,
P: SerializerParams,
[src]
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. Read more
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. Read more
type SerializeTuple = SerializeCompound<'a, W, P>
Type returned from serialize_tuple
for serializing the content of
the tuple. Read more
type SerializeTupleStruct = SerializeCompound<'a, W, P>
Type returned from serialize_tuple_struct
for serializing the
content of the tuple struct. Read more
type SerializeTupleVariant = SerializeCompound<'a, W, P>
Type returned from serialize_tuple_variant
for serializing the
content of the tuple variant. Read more
type SerializeMap = SerializeCompoundSeq<'a, W, P>
Type returned from serialize_map
for serializing the content of the
map. Read more
type SerializeStruct = SerializeCompound<'a, W, P>
Type returned from serialize_struct
for serializing the content of
the struct. Read more
type SerializeStructVariant = SerializeCompound<'a, W, P>
Type returned from serialize_struct_variant
for serializing the
content of the struct variant. Read more
pub fn serialize_bool(self, v: bool) -> Result
[src]
pub fn serialize_u8(self, v: u8) -> Result
[src]
pub fn serialize_u16(self, v: u16) -> Result
[src]
pub fn serialize_u32(self, v: u32) -> Result
[src]
pub fn serialize_u64(self, v: u64) -> Result
[src]
pub fn serialize_i8(self, v: i8) -> Result
[src]
pub fn serialize_i16(self, v: i16) -> Result
[src]
pub fn serialize_i32(self, v: i32) -> Result
[src]
pub fn serialize_i64(self, v: i64) -> Result
[src]
pub fn serialize_f32(self, v: f32) -> Result
[src]
pub fn serialize_f64(self, v: f64) -> Result
[src]
pub fn serialize_u128(self, v: u128) -> Result
[src]
pub fn serialize_i128(self, v: i128) -> Result
[src]
pub fn serialize_char(self, v: char) -> Result
[src]
pub fn serialize_str(self, v: &str) -> Result
[src]
pub fn serialize_bytes(self, v: &[u8]) -> Result
[src]
pub fn serialize_none(self) -> Result
[src]
pub fn serialize_some<T: ?Sized>(self, value: &T) -> Result where
T: Serialize,
[src]
T: Serialize,
pub fn serialize_unit(self) -> Result
[src]
pub fn serialize_unit_struct(self, _name: &'static str) -> Result
[src]
pub fn serialize_unit_variant(
self,
_name: &'static str,
variant_index: u32,
_variant: &'static str
) -> Result
[src]
self,
_name: &'static str,
variant_index: u32,
_variant: &'static str
) -> Result
pub fn serialize_newtype_struct<T: ?Sized>(
self,
_name: &'static str,
value: &T
) -> Result where
T: Serialize,
[src]
self,
_name: &'static str,
value: &T
) -> Result where
T: Serialize,
pub fn serialize_newtype_variant<T: ?Sized>(
self,
_name: &'static str,
variant_index: u32,
_variant: &'static str,
value: &T
) -> Result where
T: Serialize,
[src]
self,
_name: &'static str,
variant_index: u32,
_variant: &'static str,
value: &T
) -> Result where
T: Serialize,
pub fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple>
[src]
pub fn serialize_tuple_struct(
self,
_name: &'static str,
_len: usize
) -> Result<Self::SerializeTupleStruct>
[src]
self,
_name: &'static str,
_len: usize
) -> Result<Self::SerializeTupleStruct>
pub fn serialize_tuple_variant(
self,
_name: &'static str,
variant_index: u32,
_variant: &'static str,
_len: usize
) -> Result<Self::SerializeTupleVariant>
[src]
self,
_name: &'static str,
variant_index: u32,
_variant: &'static str,
_len: usize
) -> Result<Self::SerializeTupleVariant>
pub fn serialize_struct(
self,
_name: &'static str,
_len: usize
) -> Result<Self::SerializeStruct>
[src]
self,
_name: &'static str,
_len: usize
) -> Result<Self::SerializeStruct>
pub fn serialize_struct_variant(
self,
_name: &'static str,
variant_index: u32,
_variant: &'static str,
_len: usize
) -> Result<Self::SerializeStructVariant>
[src]
self,
_name: &'static str,
variant_index: u32,
_variant: &'static str,
_len: usize
) -> Result<Self::SerializeStructVariant>
pub fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq>
[src]
pub fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap>
[src]
pub fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
[src]
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
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,
[src]
I: IntoIterator<Item = (K, V)>,
V: Serialize,
K: Serialize,
pub fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error> where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
pub fn is_human_readable(&self) -> bool
[src]
Auto Trait Implementations
impl<W, P> RefUnwindSafe for Serializer<W, P> where
P: RefUnwindSafe,
W: RefUnwindSafe,
[src]
P: RefUnwindSafe,
W: RefUnwindSafe,
impl<W, P> Send for Serializer<W, P> where
P: Send,
W: Send,
[src]
P: Send,
W: Send,
impl<W, P> Sync for Serializer<W, P> where
P: Sync,
W: Sync,
[src]
P: Sync,
W: Sync,
impl<W, P> Unpin for Serializer<W, P> where
P: Unpin,
W: Unpin,
[src]
P: Unpin,
W: Unpin,
impl<W, P> UnwindSafe for Serializer<W, P> where
P: UnwindSafe,
W: UnwindSafe,
[src]
P: UnwindSafe,
W: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,