Trait erased_serde::Serializer
source · pub trait Serializer {
Show 31 methods
// Required methods
fn erased_serialize_bool(&mut self, v: bool) -> Result<Ok, Error>;
fn erased_serialize_i8(&mut self, v: i8) -> Result<Ok, Error>;
fn erased_serialize_i16(&mut self, v: i16) -> Result<Ok, Error>;
fn erased_serialize_i32(&mut self, v: i32) -> Result<Ok, Error>;
fn erased_serialize_i64(&mut self, v: i64) -> Result<Ok, Error>;
fn erased_serialize_i128(&mut self, v: i128) -> Result<Ok, Error>;
fn erased_serialize_u8(&mut self, v: u8) -> Result<Ok, Error>;
fn erased_serialize_u16(&mut self, v: u16) -> Result<Ok, Error>;
fn erased_serialize_u32(&mut self, v: u32) -> Result<Ok, Error>;
fn erased_serialize_u64(&mut self, v: u64) -> Result<Ok, Error>;
fn erased_serialize_u128(&mut self, v: u128) -> Result<Ok, Error>;
fn erased_serialize_f32(&mut self, v: f32) -> Result<Ok, Error>;
fn erased_serialize_f64(&mut self, v: f64) -> Result<Ok, Error>;
fn erased_serialize_char(&mut self, v: char) -> Result<Ok, Error>;
fn erased_serialize_str(&mut self, v: &str) -> Result<Ok, Error>;
fn erased_serialize_bytes(&mut self, v: &[u8]) -> Result<Ok, Error>;
fn erased_serialize_none(&mut self) -> Result<Ok, Error>;
fn erased_serialize_some(&mut self, v: &dyn Serialize) -> Result<Ok, Error>;
fn erased_serialize_unit(&mut self) -> Result<Ok, Error>;
fn erased_serialize_unit_struct(
&mut self,
name: &'static str
) -> Result<Ok, Error>;
fn erased_serialize_unit_variant(
&mut self,
name: &'static str,
variant_index: u32,
variant: &'static str
) -> Result<Ok, Error>;
fn erased_serialize_newtype_struct(
&mut self,
name: &'static str,
v: &dyn Serialize
) -> Result<Ok, Error>;
fn erased_serialize_newtype_variant(
&mut self,
name: &'static str,
variant_index: u32,
variant: &'static str,
v: &dyn Serialize
) -> Result<Ok, Error>;
fn erased_serialize_seq(
&mut self,
len: Option<usize>
) -> Result<Seq<'_>, Error>;
fn erased_serialize_tuple(&mut self, len: usize) -> Result<Tuple<'_>, Error>;
fn erased_serialize_tuple_struct(
&mut self,
name: &'static str,
len: usize
) -> Result<TupleStruct<'_>, Error>;
fn erased_serialize_tuple_variant(
&mut self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<TupleVariant<'_>, Error>;
fn erased_serialize_map(
&mut self,
len: Option<usize>
) -> Result<Map<'_>, Error>;
fn erased_serialize_struct(
&mut self,
name: &'static str,
len: usize
) -> Result<Struct<'_>, Error>;
fn erased_serialize_struct_variant(
&mut self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<StructVariant<'_>, Error>;
fn erased_is_human_readable(&self) -> bool;
}Expand description
An object-safe equivalent of Serde’s Serializer trait.
Any implementation of Serde’s Serializer can be converted to an
&erased_serde::Serializer or Box<erased_serde::Serializer> trait object
using erased_serde::Serializer::erase.
use erased_serde::{Serialize, Serializer};
use std::collections::BTreeMap as Map;
use std::io;
fn main() {
// Construct some serializers.
let json = &mut serde_json::Serializer::new(io::stdout());
let cbor = &mut serde_cbor::Serializer::new(serde_cbor::ser::IoWrite::new(io::stdout()));
// The values in this map are boxed trait objects. Ordinarily this would not
// be possible with serde::Serializer because of object safety, but type
// erasure makes it possible with erased_serde::Serializer.
let mut formats: Map<&str, Box<dyn Serializer>> = Map::new();
formats.insert("json", Box::new(<dyn Serializer>::erase(json)));
formats.insert("cbor", Box::new(<dyn Serializer>::erase(cbor)));
// These are boxed trait objects as well. Same thing here - type erasure
// makes this possible.
let mut values: Map<&str, Box<dyn Serialize>> = Map::new();
values.insert("vec", Box::new(vec!["a", "b"]));
values.insert("int", Box::new(65536));
// Pick a Serializer out of the formats map.
let format = formats.get_mut("json").unwrap();
// Pick a Serialize out of the values map.
let value = values.get("vec").unwrap();
// This line prints `["a","b"]` to stdout.
value.erased_serialize(format).unwrap();
}Required Methods§
fn erased_serialize_bool(&mut self, v: bool) -> Result<Ok, Error>
fn erased_serialize_i8(&mut self, v: i8) -> Result<Ok, Error>
fn erased_serialize_i16(&mut self, v: i16) -> Result<Ok, Error>
fn erased_serialize_i32(&mut self, v: i32) -> Result<Ok, Error>
fn erased_serialize_i64(&mut self, v: i64) -> Result<Ok, Error>
fn erased_serialize_i128(&mut self, v: i128) -> Result<Ok, Error>
fn erased_serialize_u8(&mut self, v: u8) -> Result<Ok, Error>
fn erased_serialize_u16(&mut self, v: u16) -> Result<Ok, Error>
fn erased_serialize_u32(&mut self, v: u32) -> Result<Ok, Error>
fn erased_serialize_u64(&mut self, v: u64) -> Result<Ok, Error>
fn erased_serialize_u128(&mut self, v: u128) -> Result<Ok, Error>
fn erased_serialize_f32(&mut self, v: f32) -> Result<Ok, Error>
fn erased_serialize_f64(&mut self, v: f64) -> Result<Ok, Error>
fn erased_serialize_char(&mut self, v: char) -> Result<Ok, Error>
fn erased_serialize_str(&mut self, v: &str) -> Result<Ok, Error>
fn erased_serialize_bytes(&mut self, v: &[u8]) -> Result<Ok, Error>
fn erased_serialize_none(&mut self) -> Result<Ok, Error>
fn erased_serialize_some(&mut self, v: &dyn Serialize) -> Result<Ok, Error>
fn erased_serialize_unit(&mut self) -> Result<Ok, Error>
fn erased_serialize_unit_struct( &mut self, name: &'static str ) -> Result<Ok, Error>
fn erased_serialize_unit_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str ) -> Result<Ok, Error>
fn erased_serialize_newtype_struct( &mut self, name: &'static str, v: &dyn Serialize ) -> Result<Ok, Error>
fn erased_serialize_newtype_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, v: &dyn Serialize ) -> Result<Ok, Error>
fn erased_serialize_seq(&mut self, len: Option<usize>) -> Result<Seq<'_>, Error>
fn erased_serialize_tuple(&mut self, len: usize) -> Result<Tuple<'_>, Error>
fn erased_serialize_tuple_struct( &mut self, name: &'static str, len: usize ) -> Result<TupleStruct<'_>, Error>
fn erased_serialize_tuple_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize ) -> Result<TupleVariant<'_>, Error>
fn erased_serialize_map(&mut self, len: Option<usize>) -> Result<Map<'_>, Error>
fn erased_serialize_struct( &mut self, name: &'static str, len: usize ) -> Result<Struct<'_>, Error>
fn erased_serialize_struct_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize ) -> Result<StructVariant<'_>, Error>
fn erased_is_human_readable(&self) -> bool
Implementations§
source§impl dyn Serializer
impl dyn Serializer
sourcepub fn erase<S>(serializer: S) -> Serializer<S>where
S: Serializer,
S::Ok: 'static,
pub fn erase<S>(serializer: S) -> Serializer<S>where S: Serializer, S::Ok: 'static,
Convert any Serde Serializer to a trait object.
use erased_serde::{Serialize, Serializer};
use std::collections::BTreeMap as Map;
use std::io;
fn main() {
// Construct some serializers.
let json = &mut serde_json::Serializer::new(io::stdout());
let cbor = &mut serde_cbor::Serializer::new(serde_cbor::ser::IoWrite::new(io::stdout()));
// The values in this map are boxed trait objects. Ordinarily this would not
// be possible with serde::Serializer because of object safety, but type
// erasure makes it possible with erased_serde::Serializer.
let mut formats: Map<&str, Box<dyn Serializer>> = Map::new();
formats.insert("json", Box::new(<dyn Serializer>::erase(json)));
formats.insert("cbor", Box::new(<dyn Serializer>::erase(cbor)));
// These are boxed trait objects as well. Same thing here - type erasure
// makes this possible.
let mut values: Map<&str, Box<dyn Serialize>> = Map::new();
values.insert("vec", Box::new(vec!["a", "b"]));
values.insert("int", Box::new(65536));
// Pick a Serializer out of the formats map.
let format = formats.get_mut("json").unwrap();
// Pick a Serialize out of the values map.
let value = values.get("vec").unwrap();
// This line prints `["a","b"]` to stdout.
value.erased_serialize(format).unwrap();
}Trait Implementations§
source§impl<'a> Serializer for &'a mut (dyn Serializer + '_)
impl<'a> Serializer for &'a mut (dyn Serializer + '_)
§type Ok = Ok
type Ok = 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 SerializeSeq = Seq<'a>
type SerializeSeq = Seq<'a>
Type returned from
serialize_seq for serializing the content of the
sequence.§type SerializeTuple = Tuple<'a>
type SerializeTuple = Tuple<'a>
Type returned from
serialize_tuple for serializing the content of
the tuple.§type SerializeTupleStruct = TupleStruct<'a>
type SerializeTupleStruct = TupleStruct<'a>
Type returned from
serialize_tuple_struct for serializing the
content of the tuple struct.§type SerializeTupleVariant = TupleVariant<'a>
type SerializeTupleVariant = TupleVariant<'a>
Type returned from
serialize_tuple_variant for serializing the
content of the tuple variant.§type SerializeMap = Map<'a>
type SerializeMap = Map<'a>
Type returned from
serialize_map for serializing the content of the
map.§type SerializeStruct = Struct<'a>
type SerializeStruct = Struct<'a>
Type returned from
serialize_struct for serializing the content of
the struct.§type SerializeStructVariant = StructVariant<'a>
type SerializeStructVariant = StructVariant<'a>
Type returned from
serialize_struct_variant for serializing the
content of the struct variant.source§fn serialize_bytes(self, v: &[u8]) -> Result<Ok, Error>
fn serialize_bytes(self, v: &[u8]) -> Result<Ok, 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<Ok, Error>
fn serialize_unit_variant( self, name: &'static str, variant_index: u32, variant: &'static str ) -> Result<Ok, Error>
source§fn serialize_newtype_struct<T>(
self,
name: &'static str,
v: &T
) -> Result<Ok, Error>where
T: ?Sized + Serialize,
fn serialize_newtype_struct<T>( self, name: &'static str, v: &T ) -> Result<Ok, Error>where T: ?Sized + Serialize,
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,
v: &T
) -> Result<Ok, Error>where
T: ?Sized + Serialize,
fn serialize_newtype_variant<T>( self, name: &'static str, variant_index: u32, variant: &'static str, v: &T ) -> Result<Ok, Error>where T: ?Sized + Serialize,
source§fn serialize_seq(self, len: Option<usize>) -> Result<Seq<'a>, Error>
fn serialize_seq(self, len: Option<usize>) -> Result<Seq<'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<Tuple<'a>, Error>
fn serialize_tuple(self, len: usize) -> Result<Tuple<'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<TupleStruct<'a>, Error>
fn serialize_tuple_struct( self, name: &'static str, len: usize ) -> Result<TupleStruct<'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<TupleVariant<'a>, Error>
fn serialize_tuple_variant( self, name: &'static str, variant_index: u32, variant: &'static str, len: usize ) -> Result<TupleVariant<'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<Map<'a>, Error>
fn serialize_map(self, len: Option<usize>) -> Result<Map<'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<Struct<'a>, Error>
fn serialize_struct( self, name: &'static str, len: usize ) -> Result<Struct<'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<StructVariant<'a>, Error>
fn serialize_struct_variant( self, name: &'static str, variant_index: u32, variant: &'static str, len: usize ) -> Result<StructVariant<'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 is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Determine whether
Serialize implementations should serialize in
human-readable form. Read moresource§fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>where
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
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. Read more
source§impl<'a> Serializer for &'a mut (dyn Serializer + Send + '_)
impl<'a> Serializer for &'a mut (dyn Serializer + Send + '_)
§type Ok = Ok
type Ok = 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 SerializeSeq = Seq<'a>
type SerializeSeq = Seq<'a>
Type returned from
serialize_seq for serializing the content of the
sequence.§type SerializeTuple = Tuple<'a>
type SerializeTuple = Tuple<'a>
Type returned from
serialize_tuple for serializing the content of
the tuple.§type SerializeTupleStruct = TupleStruct<'a>
type SerializeTupleStruct = TupleStruct<'a>
Type returned from
serialize_tuple_struct for serializing the
content of the tuple struct.§type SerializeTupleVariant = TupleVariant<'a>
type SerializeTupleVariant = TupleVariant<'a>
Type returned from
serialize_tuple_variant for serializing the
content of the tuple variant.§type SerializeMap = Map<'a>
type SerializeMap = Map<'a>
Type returned from
serialize_map for serializing the content of the
map.§type SerializeStruct = Struct<'a>
type SerializeStruct = Struct<'a>
Type returned from
serialize_struct for serializing the content of
the struct.§type SerializeStructVariant = StructVariant<'a>
type SerializeStructVariant = StructVariant<'a>
Type returned from
serialize_struct_variant for serializing the
content of the struct variant.source§fn serialize_bytes(self, v: &[u8]) -> Result<Ok, Error>
fn serialize_bytes(self, v: &[u8]) -> Result<Ok, 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<Ok, Error>
fn serialize_unit_variant( self, name: &'static str, variant_index: u32, variant: &'static str ) -> Result<Ok, Error>
source§fn serialize_newtype_struct<T>(
self,
name: &'static str,
v: &T
) -> Result<Ok, Error>where
T: ?Sized + Serialize,
fn serialize_newtype_struct<T>( self, name: &'static str, v: &T ) -> Result<Ok, Error>where T: ?Sized + Serialize,
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,
v: &T
) -> Result<Ok, Error>where
T: ?Sized + Serialize,
fn serialize_newtype_variant<T>( self, name: &'static str, variant_index: u32, variant: &'static str, v: &T ) -> Result<Ok, Error>where T: ?Sized + Serialize,
source§fn serialize_seq(self, len: Option<usize>) -> Result<Seq<'a>, Error>
fn serialize_seq(self, len: Option<usize>) -> Result<Seq<'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<Tuple<'a>, Error>
fn serialize_tuple(self, len: usize) -> Result<Tuple<'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<TupleStruct<'a>, Error>
fn serialize_tuple_struct( self, name: &'static str, len: usize ) -> Result<TupleStruct<'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<TupleVariant<'a>, Error>
fn serialize_tuple_variant( self, name: &'static str, variant_index: u32, variant: &'static str, len: usize ) -> Result<TupleVariant<'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<Map<'a>, Error>
fn serialize_map(self, len: Option<usize>) -> Result<Map<'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<Struct<'a>, Error>
fn serialize_struct( self, name: &'static str, len: usize ) -> Result<Struct<'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<StructVariant<'a>, Error>
fn serialize_struct_variant( self, name: &'static str, variant_index: u32, variant: &'static str, len: usize ) -> Result<StructVariant<'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 is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Determine whether
Serialize implementations should serialize in
human-readable form. Read moresource§fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>where
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
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. Read more
source§impl<'a> Serializer for &'a mut (dyn Serializer + Send + Sync + '_)
impl<'a> Serializer for &'a mut (dyn Serializer + Send + Sync + '_)
§type Ok = Ok
type Ok = 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 SerializeSeq = Seq<'a>
type SerializeSeq = Seq<'a>
Type returned from
serialize_seq for serializing the content of the
sequence.§type SerializeTuple = Tuple<'a>
type SerializeTuple = Tuple<'a>
Type returned from
serialize_tuple for serializing the content of
the tuple.§type SerializeTupleStruct = TupleStruct<'a>
type SerializeTupleStruct = TupleStruct<'a>
Type returned from
serialize_tuple_struct for serializing the
content of the tuple struct.§type SerializeTupleVariant = TupleVariant<'a>
type SerializeTupleVariant = TupleVariant<'a>
Type returned from
serialize_tuple_variant for serializing the
content of the tuple variant.§type SerializeMap = Map<'a>
type SerializeMap = Map<'a>
Type returned from
serialize_map for serializing the content of the
map.§type SerializeStruct = Struct<'a>
type SerializeStruct = Struct<'a>
Type returned from
serialize_struct for serializing the content of
the struct.§type SerializeStructVariant = StructVariant<'a>
type SerializeStructVariant = StructVariant<'a>
Type returned from
serialize_struct_variant for serializing the
content of the struct variant.source§fn serialize_bytes(self, v: &[u8]) -> Result<Ok, Error>
fn serialize_bytes(self, v: &[u8]) -> Result<Ok, 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<Ok, Error>
fn serialize_unit_variant( self, name: &'static str, variant_index: u32, variant: &'static str ) -> Result<Ok, Error>
source§fn serialize_newtype_struct<T>(
self,
name: &'static str,
v: &T
) -> Result<Ok, Error>where
T: ?Sized + Serialize,
fn serialize_newtype_struct<T>( self, name: &'static str, v: &T ) -> Result<Ok, Error>where T: ?Sized + Serialize,
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,
v: &T
) -> Result<Ok, Error>where
T: ?Sized + Serialize,
fn serialize_newtype_variant<T>( self, name: &'static str, variant_index: u32, variant: &'static str, v: &T ) -> Result<Ok, Error>where T: ?Sized + Serialize,
source§fn serialize_seq(self, len: Option<usize>) -> Result<Seq<'a>, Error>
fn serialize_seq(self, len: Option<usize>) -> Result<Seq<'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<Tuple<'a>, Error>
fn serialize_tuple(self, len: usize) -> Result<Tuple<'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<TupleStruct<'a>, Error>
fn serialize_tuple_struct( self, name: &'static str, len: usize ) -> Result<TupleStruct<'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<TupleVariant<'a>, Error>
fn serialize_tuple_variant( self, name: &'static str, variant_index: u32, variant: &'static str, len: usize ) -> Result<TupleVariant<'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<Map<'a>, Error>
fn serialize_map(self, len: Option<usize>) -> Result<Map<'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<Struct<'a>, Error>
fn serialize_struct( self, name: &'static str, len: usize ) -> Result<Struct<'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<StructVariant<'a>, Error>
fn serialize_struct_variant( self, name: &'static str, variant_index: u32, variant: &'static str, len: usize ) -> Result<StructVariant<'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 is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Determine whether
Serialize implementations should serialize in
human-readable form. Read moresource§fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>where
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
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. Read more
source§impl<'a> Serializer for &'a mut (dyn Serializer + Sync + '_)
impl<'a> Serializer for &'a mut (dyn Serializer + Sync + '_)
§type Ok = Ok
type Ok = 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 SerializeSeq = Seq<'a>
type SerializeSeq = Seq<'a>
Type returned from
serialize_seq for serializing the content of the
sequence.§type SerializeTuple = Tuple<'a>
type SerializeTuple = Tuple<'a>
Type returned from
serialize_tuple for serializing the content of
the tuple.§type SerializeTupleStruct = TupleStruct<'a>
type SerializeTupleStruct = TupleStruct<'a>
Type returned from
serialize_tuple_struct for serializing the
content of the tuple struct.§type SerializeTupleVariant = TupleVariant<'a>
type SerializeTupleVariant = TupleVariant<'a>
Type returned from
serialize_tuple_variant for serializing the
content of the tuple variant.§type SerializeMap = Map<'a>
type SerializeMap = Map<'a>
Type returned from
serialize_map for serializing the content of the
map.§type SerializeStruct = Struct<'a>
type SerializeStruct = Struct<'a>
Type returned from
serialize_struct for serializing the content of
the struct.§type SerializeStructVariant = StructVariant<'a>
type SerializeStructVariant = StructVariant<'a>
Type returned from
serialize_struct_variant for serializing the
content of the struct variant.source§fn serialize_bytes(self, v: &[u8]) -> Result<Ok, Error>
fn serialize_bytes(self, v: &[u8]) -> Result<Ok, 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<Ok, Error>
fn serialize_unit_variant( self, name: &'static str, variant_index: u32, variant: &'static str ) -> Result<Ok, Error>
source§fn serialize_newtype_struct<T>(
self,
name: &'static str,
v: &T
) -> Result<Ok, Error>where
T: ?Sized + Serialize,
fn serialize_newtype_struct<T>( self, name: &'static str, v: &T ) -> Result<Ok, Error>where T: ?Sized + Serialize,
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,
v: &T
) -> Result<Ok, Error>where
T: ?Sized + Serialize,
fn serialize_newtype_variant<T>( self, name: &'static str, variant_index: u32, variant: &'static str, v: &T ) -> Result<Ok, Error>where T: ?Sized + Serialize,
source§fn serialize_seq(self, len: Option<usize>) -> Result<Seq<'a>, Error>
fn serialize_seq(self, len: Option<usize>) -> Result<Seq<'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<Tuple<'a>, Error>
fn serialize_tuple(self, len: usize) -> Result<Tuple<'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<TupleStruct<'a>, Error>
fn serialize_tuple_struct( self, name: &'static str, len: usize ) -> Result<TupleStruct<'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<TupleVariant<'a>, Error>
fn serialize_tuple_variant( self, name: &'static str, variant_index: u32, variant: &'static str, len: usize ) -> Result<TupleVariant<'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<Map<'a>, Error>
fn serialize_map(self, len: Option<usize>) -> Result<Map<'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<Struct<'a>, Error>
fn serialize_struct( self, name: &'static str, len: usize ) -> Result<Struct<'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<StructVariant<'a>, Error>
fn serialize_struct_variant( self, name: &'static str, variant_index: u32, variant: &'static str, len: usize ) -> Result<StructVariant<'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 is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Determine whether
Serialize implementations should serialize in
human-readable form. Read moresource§fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>where
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
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. Read more