Struct serde_assert::Serializer
source · pub struct Serializer { /* private fields */ }
Expand description
Serializer for testing Serialize
implementations.
This serializer outputs Tokens
representing the serialized value. The Tokens
can be
compared against an expected sequence of Token
s to ensure the serialization is correct.
Configuration
The following options can be configured on the Builder
:
is_human_readable()
: Determines whether the serializer will serialize values in a readable format or a compact format. Useful for complicated structs wishing to provide different outputs depending on the readability of the serialization type.serialize_struct_as()
: Specifies how the serializer should serialize structs. Compact formats often serialize structs as sequences. By enabling this setting, tokens can be produced in this format, and can then be deserialized to ensure structs deserialized as sequences are deserialized correctly.
Example
use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
Serializer,
Token,
};
let serializer = Serializer::builder().build();
assert_ok_eq!(true.serialize(&serializer), [Token::Bool(true)]);
Implementations§
source§impl Serializer
impl Serializer
Trait Implementations§
source§impl Debug for Serializer
impl Debug for Serializer
source§impl<'a> Serializer for &'a Serializer
impl<'a> Serializer for &'a Serializer
§type Ok = Tokens
type Ok = Tokens
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 SerializeSeq = CompoundSerializer<'a>
type SerializeSeq = CompoundSerializer<'a>
Type returned from
serialize_seq
for serializing the content of the
sequence.§type SerializeTuple = CompoundSerializer<'a>
type SerializeTuple = CompoundSerializer<'a>
Type returned from
serialize_tuple
for serializing the content of
the tuple.§type SerializeTupleStruct = CompoundSerializer<'a>
type SerializeTupleStruct = CompoundSerializer<'a>
Type returned from
serialize_tuple_struct
for serializing the
content of the tuple struct.§type SerializeTupleVariant = CompoundSerializer<'a>
type SerializeTupleVariant = CompoundSerializer<'a>
Type returned from
serialize_tuple_variant
for serializing the
content of the tuple variant.§type SerializeMap = CompoundSerializer<'a>
type SerializeMap = CompoundSerializer<'a>
Type returned from
serialize_map
for serializing the content of the
map.§type SerializeStruct = SerializeStruct<'a>
type SerializeStruct = SerializeStruct<'a>
Type returned from
serialize_struct
for serializing the content of
the struct.§type SerializeStructVariant = CompoundSerializer<'a>
type SerializeStructVariant = CompoundSerializer<'a>
Type returned from
serialize_struct_variant
for serializing the
content of the struct variant.source§fn serialize_bytes(self, v: &[u8]) -> Result<Tokens, Error>
fn serialize_bytes(self, v: &[u8]) -> Result<Tokens, Error>
Serialize a chunk of raw byte data. Read more
source§fn serialize_unit_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str
) -> Result<Tokens, Error>
fn serialize_unit_variant( self, name: &'static str, variant_index: u32, variant: &'static str ) -> Result<Tokens, Error>
source§fn serialize_newtype_struct<T>(
self,
name: &'static str,
value: &T
) -> Result<Tokens, Error>
fn serialize_newtype_struct<T>( self, name: &'static str, value: &T ) -> Result<Tokens, Error>
Serialize a newtype struct like
struct Millimeters(u8)
. Read moresource§fn serialize_newtype_variant<T>(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
value: &T
) -> Result<Tokens, Error>
fn serialize_newtype_variant<T>( self, name: &'static str, variant_index: u32, variant: &'static str, value: &T ) -> Result<Tokens, Error>
source§fn serialize_seq(
self,
len: Option<usize>
) -> Result<CompoundSerializer<'a>, Error>
fn serialize_seq( self, len: Option<usize> ) -> Result<CompoundSerializer<'a>, Error>
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
. Read moresource§fn serialize_tuple(self, len: usize) -> Result<CompoundSerializer<'a>, Error>
fn serialize_tuple(self, len: usize) -> Result<CompoundSerializer<'a>, Error>
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
. Read moresource§fn serialize_tuple_struct(
self,
name: &'static str,
len: usize
) -> Result<CompoundSerializer<'a>, Error>
fn serialize_tuple_struct( self, name: &'static str, len: usize ) -> Result<CompoundSerializer<'a>, Error>
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
. Read moresource§fn serialize_tuple_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<CompoundSerializer<'a>, Error>
fn serialize_tuple_variant( self, name: &'static str, variant_index: u32, variant: &'static str, len: usize ) -> Result<CompoundSerializer<'a>, Error>
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
. Read moresource§fn serialize_map(
self,
len: Option<usize>
) -> Result<CompoundSerializer<'a>, Error>
fn serialize_map( self, len: Option<usize> ) -> Result<CompoundSerializer<'a>, Error>
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
. Read moresource§fn serialize_struct(
self,
name: &'static str,
len: usize
) -> Result<SerializeStruct<'a>, Error>
fn serialize_struct( self, name: &'static str, len: usize ) -> Result<SerializeStruct<'a>, Error>
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
. Read moresource§fn serialize_struct_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<CompoundSerializer<'a>, Error>
fn serialize_struct_variant( self, name: &'static str, variant_index: u32, variant: &'static str, len: usize ) -> Result<CompoundSerializer<'a>, Error>
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
. Read moresource§fn collect_str<T>(self, value: &T) -> Result<Tokens, Error>
fn collect_str<T>(self, value: &T) -> Result<Tokens, Error>
Serialize a string produced by an implementation of
Display
. Read moresource§fn is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Determine whether
Serialize
implementations should serialize in
human-readable form. Read moreAuto Trait Implementations§
impl RefUnwindSafe for Serializer
impl Send for Serializer
impl Sync for Serializer
impl Unpin for Serializer
impl UnwindSafe for Serializer
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more