Trait erased_serde::Serializer [−][src]
pub trait Serializer {}Show 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_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_i128(&mut self, v: i128) -> 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;
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(Serializer::erase(json))); formats.insert("cbor", Box::new(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>
[src]
fn erased_serialize_i8(&mut self, v: i8) -> Result<Ok, Error>
[src]
fn erased_serialize_i16(&mut self, v: i16) -> Result<Ok, Error>
[src]
fn erased_serialize_i32(&mut self, v: i32) -> Result<Ok, Error>
[src]
fn erased_serialize_i64(&mut self, v: i64) -> Result<Ok, Error>
[src]
fn erased_serialize_u8(&mut self, v: u8) -> Result<Ok, Error>
[src]
fn erased_serialize_u16(&mut self, v: u16) -> Result<Ok, Error>
[src]
fn erased_serialize_u32(&mut self, v: u32) -> Result<Ok, Error>
[src]
fn erased_serialize_u64(&mut self, v: u64) -> Result<Ok, Error>
[src]
fn erased_serialize_i128(&mut self, v: i128) -> Result<Ok, Error>
[src]
fn erased_serialize_u128(&mut self, v: u128) -> Result<Ok, Error>
[src]
fn erased_serialize_f32(&mut self, v: f32) -> Result<Ok, Error>
[src]
fn erased_serialize_f64(&mut self, v: f64) -> Result<Ok, Error>
[src]
fn erased_serialize_char(&mut self, v: char) -> Result<Ok, Error>
[src]
fn erased_serialize_str(&mut self, v: &str) -> Result<Ok, Error>
[src]
fn erased_serialize_bytes(&mut self, v: &[u8]) -> Result<Ok, Error>
[src]
fn erased_serialize_none(&mut self) -> Result<Ok, Error>
[src]
fn erased_serialize_some(&mut self, v: &dyn Serialize) -> Result<Ok, Error>
[src]
fn erased_serialize_unit(&mut self) -> Result<Ok, Error>
[src]
fn erased_serialize_unit_struct(
&mut self,
name: &'static str
) -> Result<Ok, Error>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
fn erased_serialize_tuple(&mut self, len: usize) -> Result<Tuple<'_>, Error>
[src]
fn erased_serialize_tuple_struct(
&mut self,
name: &'static str,
len: usize
) -> Result<TupleStruct<'_>, Error>
[src]
&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>
[src]
&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>
[src]
fn erased_serialize_struct(
&mut self,
name: &'static str,
len: usize
) -> Result<Struct<'_>, Error>
[src]
&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>
[src]
&mut self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<StructVariant<'_>, Error>
fn erased_is_human_readable(&self) -> bool
[src]
Implementations
impl dyn Serializer
[src]
impl dyn Serializer
[src]pub fn erase<S>(serializer: S) -> Serializer<S> where
S: Serializer,
S::Ok: 'static,
[src]
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(Serializer::erase(json))); formats.insert("cbor", Box::new(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
impl<'a> Serializer for &'a mut dyn Serializer
[src]
impl<'a> Serializer for &'a mut dyn Serializer
[src]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. Read more
type Error = Error
The error type when some error occurs during serialization.
type SerializeSeq = Seq<'a>
Type returned from serialize_seq
for serializing the content of the
sequence. Read more
type SerializeTuple = Tuple<'a>
Type returned from serialize_tuple
for serializing the content of
the tuple. Read more
type SerializeTupleStruct = TupleStruct<'a>
Type returned from serialize_tuple_struct
for serializing the
content of the tuple struct. Read more
type SerializeTupleVariant = TupleVariant<'a>
Type returned from serialize_tuple_variant
for serializing the
content of the tuple variant. Read more
type SerializeMap = Map<'a>
Type returned from serialize_map
for serializing the content of the
map. Read more
type SerializeStruct = Struct<'a>
Type returned from serialize_struct
for serializing the content of
the struct. Read more
type SerializeStructVariant = StructVariant<'a>
Type returned from serialize_struct_variant
for serializing the
content of the struct variant. Read more
fn serialize_bool(self, v: bool) -> Result<Ok, Error>
[src]
fn serialize_i8(self, v: i8) -> Result<Ok, Error>
[src]
fn serialize_i16(self, v: i16) -> Result<Ok, Error>
[src]
fn serialize_i32(self, v: i32) -> Result<Ok, Error>
[src]
fn serialize_i64(self, v: i64) -> Result<Ok, Error>
[src]
fn serialize_u8(self, v: u8) -> Result<Ok, Error>
[src]
fn serialize_u16(self, v: u16) -> Result<Ok, Error>
[src]
fn serialize_u32(self, v: u32) -> Result<Ok, Error>
[src]
fn serialize_u64(self, v: u64) -> Result<Ok, Error>
[src]
fn serialize_i128(self, v: i128) -> Result<Ok, Error>
[src]
fn serialize_u128(self, v: u128) -> Result<Ok, Error>
[src]
fn serialize_f32(self, v: f32) -> Result<Ok, Error>
[src]
fn serialize_f64(self, v: f64) -> Result<Ok, Error>
[src]
fn serialize_char(self, v: char) -> Result<Ok, Error>
[src]
fn serialize_str(self, v: &str) -> Result<Ok, Error>
[src]
fn serialize_bytes(self, v: &[u8]) -> Result<Ok, Error>
[src]
fn serialize_none(self) -> Result<Ok, Error>
[src]
fn serialize_some<T: ?Sized + Serialize>(self, v: &T) -> Result<Ok, Error>
[src]
fn serialize_unit(self) -> Result<Ok, Error>
[src]
fn serialize_unit_struct(self, name: &'static str) -> Result<Ok, Error>
[src]
fn serialize_unit_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str
) -> Result<Ok, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str
) -> Result<Ok, Error>
fn serialize_newtype_struct<T: ?Sized + Serialize>(
self,
name: &'static str,
v: &T
) -> Result<Ok, Error>
[src]
self,
name: &'static str,
v: &T
) -> Result<Ok, Error>
fn serialize_newtype_variant<T: ?Sized + Serialize>(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
v: &T
) -> Result<Ok, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
v: &T
) -> Result<Ok, Error>
fn serialize_seq(self, len: Option<usize>) -> Result<Seq<'a>, Error>
[src]
fn serialize_tuple(self, len: usize) -> Result<Tuple<'a>, Error>
[src]
fn serialize_tuple_struct(
self,
name: &'static str,
len: usize
) -> Result<TupleStruct<'a>, Error>
[src]
self,
name: &'static str,
len: usize
) -> Result<TupleStruct<'a>, Error>
fn serialize_tuple_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<TupleVariant<'a>, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<TupleVariant<'a>, Error>
fn serialize_map(self, len: Option<usize>) -> Result<Map<'a>, Error>
[src]
fn serialize_struct(
self,
name: &'static str,
len: usize
) -> Result<Struct<'a>, Error>
[src]
self,
name: &'static str,
len: usize
) -> Result<Struct<'a>, Error>
fn serialize_struct_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<StructVariant<'a>, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<StructVariant<'a>, Error>
fn is_human_readable(&self) -> bool
[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
V: Serialize,
K: Serialize,
I: IntoIterator<Item = (K, V)>,
[src]
V: Serialize,
K: Serialize,
I: IntoIterator<Item = (K, V)>,
pub fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error> where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<'a> Serializer for &'a mut (dyn Serializer + Send)
[src]
impl<'a> Serializer for &'a mut (dyn Serializer + Send)
[src]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. Read more
type Error = Error
The error type when some error occurs during serialization.
type SerializeSeq = Seq<'a>
Type returned from serialize_seq
for serializing the content of the
sequence. Read more
type SerializeTuple = Tuple<'a>
Type returned from serialize_tuple
for serializing the content of
the tuple. Read more
type SerializeTupleStruct = TupleStruct<'a>
Type returned from serialize_tuple_struct
for serializing the
content of the tuple struct. Read more
type SerializeTupleVariant = TupleVariant<'a>
Type returned from serialize_tuple_variant
for serializing the
content of the tuple variant. Read more
type SerializeMap = Map<'a>
Type returned from serialize_map
for serializing the content of the
map. Read more
type SerializeStruct = Struct<'a>
Type returned from serialize_struct
for serializing the content of
the struct. Read more
type SerializeStructVariant = StructVariant<'a>
Type returned from serialize_struct_variant
for serializing the
content of the struct variant. Read more
fn serialize_bool(self, v: bool) -> Result<Ok, Error>
[src]
fn serialize_i8(self, v: i8) -> Result<Ok, Error>
[src]
fn serialize_i16(self, v: i16) -> Result<Ok, Error>
[src]
fn serialize_i32(self, v: i32) -> Result<Ok, Error>
[src]
fn serialize_i64(self, v: i64) -> Result<Ok, Error>
[src]
fn serialize_u8(self, v: u8) -> Result<Ok, Error>
[src]
fn serialize_u16(self, v: u16) -> Result<Ok, Error>
[src]
fn serialize_u32(self, v: u32) -> Result<Ok, Error>
[src]
fn serialize_u64(self, v: u64) -> Result<Ok, Error>
[src]
fn serialize_i128(self, v: i128) -> Result<Ok, Error>
[src]
fn serialize_u128(self, v: u128) -> Result<Ok, Error>
[src]
fn serialize_f32(self, v: f32) -> Result<Ok, Error>
[src]
fn serialize_f64(self, v: f64) -> Result<Ok, Error>
[src]
fn serialize_char(self, v: char) -> Result<Ok, Error>
[src]
fn serialize_str(self, v: &str) -> Result<Ok, Error>
[src]
fn serialize_bytes(self, v: &[u8]) -> Result<Ok, Error>
[src]
fn serialize_none(self) -> Result<Ok, Error>
[src]
fn serialize_some<T: ?Sized + Serialize>(self, v: &T) -> Result<Ok, Error>
[src]
fn serialize_unit(self) -> Result<Ok, Error>
[src]
fn serialize_unit_struct(self, name: &'static str) -> Result<Ok, Error>
[src]
fn serialize_unit_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str
) -> Result<Ok, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str
) -> Result<Ok, Error>
fn serialize_newtype_struct<T: ?Sized + Serialize>(
self,
name: &'static str,
v: &T
) -> Result<Ok, Error>
[src]
self,
name: &'static str,
v: &T
) -> Result<Ok, Error>
fn serialize_newtype_variant<T: ?Sized + Serialize>(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
v: &T
) -> Result<Ok, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
v: &T
) -> Result<Ok, Error>
fn serialize_seq(self, len: Option<usize>) -> Result<Seq<'a>, Error>
[src]
fn serialize_tuple(self, len: usize) -> Result<Tuple<'a>, Error>
[src]
fn serialize_tuple_struct(
self,
name: &'static str,
len: usize
) -> Result<TupleStruct<'a>, Error>
[src]
self,
name: &'static str,
len: usize
) -> Result<TupleStruct<'a>, Error>
fn serialize_tuple_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<TupleVariant<'a>, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<TupleVariant<'a>, Error>
fn serialize_map(self, len: Option<usize>) -> Result<Map<'a>, Error>
[src]
fn serialize_struct(
self,
name: &'static str,
len: usize
) -> Result<Struct<'a>, Error>
[src]
self,
name: &'static str,
len: usize
) -> Result<Struct<'a>, Error>
fn serialize_struct_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<StructVariant<'a>, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<StructVariant<'a>, Error>
fn is_human_readable(&self) -> bool
[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
V: Serialize,
K: Serialize,
I: IntoIterator<Item = (K, V)>,
[src]
V: Serialize,
K: Serialize,
I: IntoIterator<Item = (K, V)>,
pub fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error> where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<'a> Serializer for &'a mut (dyn Serializer + Sync)
[src]
impl<'a> Serializer for &'a mut (dyn Serializer + Sync)
[src]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. Read more
type Error = Error
The error type when some error occurs during serialization.
type SerializeSeq = Seq<'a>
Type returned from serialize_seq
for serializing the content of the
sequence. Read more
type SerializeTuple = Tuple<'a>
Type returned from serialize_tuple
for serializing the content of
the tuple. Read more
type SerializeTupleStruct = TupleStruct<'a>
Type returned from serialize_tuple_struct
for serializing the
content of the tuple struct. Read more
type SerializeTupleVariant = TupleVariant<'a>
Type returned from serialize_tuple_variant
for serializing the
content of the tuple variant. Read more
type SerializeMap = Map<'a>
Type returned from serialize_map
for serializing the content of the
map. Read more
type SerializeStruct = Struct<'a>
Type returned from serialize_struct
for serializing the content of
the struct. Read more
type SerializeStructVariant = StructVariant<'a>
Type returned from serialize_struct_variant
for serializing the
content of the struct variant. Read more
fn serialize_bool(self, v: bool) -> Result<Ok, Error>
[src]
fn serialize_i8(self, v: i8) -> Result<Ok, Error>
[src]
fn serialize_i16(self, v: i16) -> Result<Ok, Error>
[src]
fn serialize_i32(self, v: i32) -> Result<Ok, Error>
[src]
fn serialize_i64(self, v: i64) -> Result<Ok, Error>
[src]
fn serialize_u8(self, v: u8) -> Result<Ok, Error>
[src]
fn serialize_u16(self, v: u16) -> Result<Ok, Error>
[src]
fn serialize_u32(self, v: u32) -> Result<Ok, Error>
[src]
fn serialize_u64(self, v: u64) -> Result<Ok, Error>
[src]
fn serialize_i128(self, v: i128) -> Result<Ok, Error>
[src]
fn serialize_u128(self, v: u128) -> Result<Ok, Error>
[src]
fn serialize_f32(self, v: f32) -> Result<Ok, Error>
[src]
fn serialize_f64(self, v: f64) -> Result<Ok, Error>
[src]
fn serialize_char(self, v: char) -> Result<Ok, Error>
[src]
fn serialize_str(self, v: &str) -> Result<Ok, Error>
[src]
fn serialize_bytes(self, v: &[u8]) -> Result<Ok, Error>
[src]
fn serialize_none(self) -> Result<Ok, Error>
[src]
fn serialize_some<T: ?Sized + Serialize>(self, v: &T) -> Result<Ok, Error>
[src]
fn serialize_unit(self) -> Result<Ok, Error>
[src]
fn serialize_unit_struct(self, name: &'static str) -> Result<Ok, Error>
[src]
fn serialize_unit_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str
) -> Result<Ok, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str
) -> Result<Ok, Error>
fn serialize_newtype_struct<T: ?Sized + Serialize>(
self,
name: &'static str,
v: &T
) -> Result<Ok, Error>
[src]
self,
name: &'static str,
v: &T
) -> Result<Ok, Error>
fn serialize_newtype_variant<T: ?Sized + Serialize>(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
v: &T
) -> Result<Ok, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
v: &T
) -> Result<Ok, Error>
fn serialize_seq(self, len: Option<usize>) -> Result<Seq<'a>, Error>
[src]
fn serialize_tuple(self, len: usize) -> Result<Tuple<'a>, Error>
[src]
fn serialize_tuple_struct(
self,
name: &'static str,
len: usize
) -> Result<TupleStruct<'a>, Error>
[src]
self,
name: &'static str,
len: usize
) -> Result<TupleStruct<'a>, Error>
fn serialize_tuple_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<TupleVariant<'a>, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<TupleVariant<'a>, Error>
fn serialize_map(self, len: Option<usize>) -> Result<Map<'a>, Error>
[src]
fn serialize_struct(
self,
name: &'static str,
len: usize
) -> Result<Struct<'a>, Error>
[src]
self,
name: &'static str,
len: usize
) -> Result<Struct<'a>, Error>
fn serialize_struct_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<StructVariant<'a>, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<StructVariant<'a>, Error>
fn is_human_readable(&self) -> bool
[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
V: Serialize,
K: Serialize,
I: IntoIterator<Item = (K, V)>,
[src]
V: Serialize,
K: Serialize,
I: IntoIterator<Item = (K, V)>,
pub fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error> where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<'a> Serializer for &'a mut (dyn Serializer + Send + Sync)
[src]
impl<'a> Serializer for &'a mut (dyn Serializer + Send + Sync)
[src]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. Read more
type Error = Error
The error type when some error occurs during serialization.
type SerializeSeq = Seq<'a>
Type returned from serialize_seq
for serializing the content of the
sequence. Read more
type SerializeTuple = Tuple<'a>
Type returned from serialize_tuple
for serializing the content of
the tuple. Read more
type SerializeTupleStruct = TupleStruct<'a>
Type returned from serialize_tuple_struct
for serializing the
content of the tuple struct. Read more
type SerializeTupleVariant = TupleVariant<'a>
Type returned from serialize_tuple_variant
for serializing the
content of the tuple variant. Read more
type SerializeMap = Map<'a>
Type returned from serialize_map
for serializing the content of the
map. Read more
type SerializeStruct = Struct<'a>
Type returned from serialize_struct
for serializing the content of
the struct. Read more
type SerializeStructVariant = StructVariant<'a>
Type returned from serialize_struct_variant
for serializing the
content of the struct variant. Read more
fn serialize_bool(self, v: bool) -> Result<Ok, Error>
[src]
fn serialize_i8(self, v: i8) -> Result<Ok, Error>
[src]
fn serialize_i16(self, v: i16) -> Result<Ok, Error>
[src]
fn serialize_i32(self, v: i32) -> Result<Ok, Error>
[src]
fn serialize_i64(self, v: i64) -> Result<Ok, Error>
[src]
fn serialize_u8(self, v: u8) -> Result<Ok, Error>
[src]
fn serialize_u16(self, v: u16) -> Result<Ok, Error>
[src]
fn serialize_u32(self, v: u32) -> Result<Ok, Error>
[src]
fn serialize_u64(self, v: u64) -> Result<Ok, Error>
[src]
fn serialize_i128(self, v: i128) -> Result<Ok, Error>
[src]
fn serialize_u128(self, v: u128) -> Result<Ok, Error>
[src]
fn serialize_f32(self, v: f32) -> Result<Ok, Error>
[src]
fn serialize_f64(self, v: f64) -> Result<Ok, Error>
[src]
fn serialize_char(self, v: char) -> Result<Ok, Error>
[src]
fn serialize_str(self, v: &str) -> Result<Ok, Error>
[src]
fn serialize_bytes(self, v: &[u8]) -> Result<Ok, Error>
[src]
fn serialize_none(self) -> Result<Ok, Error>
[src]
fn serialize_some<T: ?Sized + Serialize>(self, v: &T) -> Result<Ok, Error>
[src]
fn serialize_unit(self) -> Result<Ok, Error>
[src]
fn serialize_unit_struct(self, name: &'static str) -> Result<Ok, Error>
[src]
fn serialize_unit_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str
) -> Result<Ok, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str
) -> Result<Ok, Error>
fn serialize_newtype_struct<T: ?Sized + Serialize>(
self,
name: &'static str,
v: &T
) -> Result<Ok, Error>
[src]
self,
name: &'static str,
v: &T
) -> Result<Ok, Error>
fn serialize_newtype_variant<T: ?Sized + Serialize>(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
v: &T
) -> Result<Ok, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
v: &T
) -> Result<Ok, Error>
fn serialize_seq(self, len: Option<usize>) -> Result<Seq<'a>, Error>
[src]
fn serialize_tuple(self, len: usize) -> Result<Tuple<'a>, Error>
[src]
fn serialize_tuple_struct(
self,
name: &'static str,
len: usize
) -> Result<TupleStruct<'a>, Error>
[src]
self,
name: &'static str,
len: usize
) -> Result<TupleStruct<'a>, Error>
fn serialize_tuple_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<TupleVariant<'a>, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<TupleVariant<'a>, Error>
fn serialize_map(self, len: Option<usize>) -> Result<Map<'a>, Error>
[src]
fn serialize_struct(
self,
name: &'static str,
len: usize
) -> Result<Struct<'a>, Error>
[src]
self,
name: &'static str,
len: usize
) -> Result<Struct<'a>, Error>
fn serialize_struct_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<StructVariant<'a>, Error>
[src]
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<StructVariant<'a>, Error>
fn is_human_readable(&self) -> bool
[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
V: Serialize,
K: Serialize,
I: IntoIterator<Item = (K, V)>,
[src]
V: Serialize,
K: Serialize,
I: IntoIterator<Item = (K, V)>,
pub fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error> where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
Implementations on Foreign Types
impl<'a> Serializer for Box<dyn Serializer + 'a>
[src]
impl<'a> Serializer for Box<dyn Serializer + 'a>
[src]fn erased_serialize_bool(&mut self, v: bool) -> Result<Ok, Error>
[src]
fn erased_serialize_i8(&mut self, v: i8) -> Result<Ok, Error>
[src]
fn erased_serialize_i16(&mut self, v: i16) -> Result<Ok, Error>
[src]
fn erased_serialize_i32(&mut self, v: i32) -> Result<Ok, Error>
[src]
fn erased_serialize_i64(&mut self, v: i64) -> Result<Ok, Error>
[src]
fn erased_serialize_u8(&mut self, v: u8) -> Result<Ok, Error>
[src]
fn erased_serialize_u16(&mut self, v: u16) -> Result<Ok, Error>
[src]
fn erased_serialize_u32(&mut self, v: u32) -> Result<Ok, Error>
[src]
fn erased_serialize_u64(&mut self, v: u64) -> Result<Ok, Error>
[src]
fn erased_serialize_i128(&mut self, v: i128) -> Result<Ok, Error>
[src]
fn erased_serialize_u128(&mut self, v: u128) -> Result<Ok, Error>
[src]
fn erased_serialize_f32(&mut self, v: f32) -> Result<Ok, Error>
[src]
fn erased_serialize_f64(&mut self, v: f64) -> Result<Ok, Error>
[src]
fn erased_serialize_char(&mut self, v: char) -> Result<Ok, Error>
[src]
fn erased_serialize_str(&mut self, v: &str) -> Result<Ok, Error>
[src]
fn erased_serialize_bytes(&mut self, v: &[u8]) -> Result<Ok, Error>
[src]
fn erased_serialize_none(&mut self) -> Result<Ok, Error>
[src]
fn erased_serialize_some(&mut self, v: &dyn Serialize) -> Result<Ok, Error>
[src]
fn erased_serialize_unit(&mut self) -> Result<Ok, Error>
[src]
fn erased_serialize_unit_struct(
&mut self,
name: &'static str
) -> Result<Ok, Error>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
fn erased_serialize_tuple(&mut self, len: usize) -> Result<Tuple<'_>, Error>
[src]
fn erased_serialize_tuple_struct(
&mut self,
name: &'static str,
len: usize
) -> Result<TupleStruct<'_>, Error>
[src]
&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>
[src]
&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>
[src]
fn erased_serialize_struct(
&mut self,
name: &'static str,
len: usize
) -> Result<Struct<'_>, Error>
[src]
&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>
[src]
&mut self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<StructVariant<'_>, Error>
fn erased_is_human_readable(&self) -> bool
[src]
impl<'a> Serializer for Box<dyn Serializer + Send + 'a>
[src]
impl<'a> Serializer for Box<dyn Serializer + Send + 'a>
[src]fn erased_serialize_bool(&mut self, v: bool) -> Result<Ok, Error>
[src]
fn erased_serialize_i8(&mut self, v: i8) -> Result<Ok, Error>
[src]
fn erased_serialize_i16(&mut self, v: i16) -> Result<Ok, Error>
[src]
fn erased_serialize_i32(&mut self, v: i32) -> Result<Ok, Error>
[src]
fn erased_serialize_i64(&mut self, v: i64) -> Result<Ok, Error>
[src]
fn erased_serialize_u8(&mut self, v: u8) -> Result<Ok, Error>
[src]
fn erased_serialize_u16(&mut self, v: u16) -> Result<Ok, Error>
[src]
fn erased_serialize_u32(&mut self, v: u32) -> Result<Ok, Error>
[src]
fn erased_serialize_u64(&mut self, v: u64) -> Result<Ok, Error>
[src]
fn erased_serialize_i128(&mut self, v: i128) -> Result<Ok, Error>
[src]
fn erased_serialize_u128(&mut self, v: u128) -> Result<Ok, Error>
[src]
fn erased_serialize_f32(&mut self, v: f32) -> Result<Ok, Error>
[src]
fn erased_serialize_f64(&mut self, v: f64) -> Result<Ok, Error>
[src]
fn erased_serialize_char(&mut self, v: char) -> Result<Ok, Error>
[src]
fn erased_serialize_str(&mut self, v: &str) -> Result<Ok, Error>
[src]
fn erased_serialize_bytes(&mut self, v: &[u8]) -> Result<Ok, Error>
[src]
fn erased_serialize_none(&mut self) -> Result<Ok, Error>
[src]
fn erased_serialize_some(&mut self, v: &dyn Serialize) -> Result<Ok, Error>
[src]
fn erased_serialize_unit(&mut self) -> Result<Ok, Error>
[src]
fn erased_serialize_unit_struct(
&mut self,
name: &'static str
) -> Result<Ok, Error>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
fn erased_serialize_tuple(&mut self, len: usize) -> Result<Tuple<'_>, Error>
[src]
fn erased_serialize_tuple_struct(
&mut self,
name: &'static str,
len: usize
) -> Result<TupleStruct<'_>, Error>
[src]
&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>
[src]
&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>
[src]
fn erased_serialize_struct(
&mut self,
name: &'static str,
len: usize
) -> Result<Struct<'_>, Error>
[src]
&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>
[src]
&mut self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<StructVariant<'_>, Error>
fn erased_is_human_readable(&self) -> bool
[src]
impl<'a> Serializer for Box<dyn Serializer + Sync + 'a>
[src]
impl<'a> Serializer for Box<dyn Serializer + Sync + 'a>
[src]fn erased_serialize_bool(&mut self, v: bool) -> Result<Ok, Error>
[src]
fn erased_serialize_i8(&mut self, v: i8) -> Result<Ok, Error>
[src]
fn erased_serialize_i16(&mut self, v: i16) -> Result<Ok, Error>
[src]
fn erased_serialize_i32(&mut self, v: i32) -> Result<Ok, Error>
[src]
fn erased_serialize_i64(&mut self, v: i64) -> Result<Ok, Error>
[src]
fn erased_serialize_u8(&mut self, v: u8) -> Result<Ok, Error>
[src]
fn erased_serialize_u16(&mut self, v: u16) -> Result<Ok, Error>
[src]
fn erased_serialize_u32(&mut self, v: u32) -> Result<Ok, Error>
[src]
fn erased_serialize_u64(&mut self, v: u64) -> Result<Ok, Error>
[src]
fn erased_serialize_i128(&mut self, v: i128) -> Result<Ok, Error>
[src]
fn erased_serialize_u128(&mut self, v: u128) -> Result<Ok, Error>
[src]
fn erased_serialize_f32(&mut self, v: f32) -> Result<Ok, Error>
[src]
fn erased_serialize_f64(&mut self, v: f64) -> Result<Ok, Error>
[src]
fn erased_serialize_char(&mut self, v: char) -> Result<Ok, Error>
[src]
fn erased_serialize_str(&mut self, v: &str) -> Result<Ok, Error>
[src]
fn erased_serialize_bytes(&mut self, v: &[u8]) -> Result<Ok, Error>
[src]
fn erased_serialize_none(&mut self) -> Result<Ok, Error>
[src]
fn erased_serialize_some(&mut self, v: &dyn Serialize) -> Result<Ok, Error>
[src]
fn erased_serialize_unit(&mut self) -> Result<Ok, Error>
[src]
fn erased_serialize_unit_struct(
&mut self,
name: &'static str
) -> Result<Ok, Error>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
fn erased_serialize_tuple(&mut self, len: usize) -> Result<Tuple<'_>, Error>
[src]
fn erased_serialize_tuple_struct(
&mut self,
name: &'static str,
len: usize
) -> Result<TupleStruct<'_>, Error>
[src]
&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>
[src]
&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>
[src]
fn erased_serialize_struct(
&mut self,
name: &'static str,
len: usize
) -> Result<Struct<'_>, Error>
[src]
&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>
[src]
&mut self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<StructVariant<'_>, Error>
fn erased_is_human_readable(&self) -> bool
[src]
impl<'a> Serializer for Box<dyn Serializer + Send + Sync + 'a>
[src]
impl<'a> Serializer for Box<dyn Serializer + Send + Sync + 'a>
[src]fn erased_serialize_bool(&mut self, v: bool) -> Result<Ok, Error>
[src]
fn erased_serialize_i8(&mut self, v: i8) -> Result<Ok, Error>
[src]
fn erased_serialize_i16(&mut self, v: i16) -> Result<Ok, Error>
[src]
fn erased_serialize_i32(&mut self, v: i32) -> Result<Ok, Error>
[src]
fn erased_serialize_i64(&mut self, v: i64) -> Result<Ok, Error>
[src]
fn erased_serialize_u8(&mut self, v: u8) -> Result<Ok, Error>
[src]
fn erased_serialize_u16(&mut self, v: u16) -> Result<Ok, Error>
[src]
fn erased_serialize_u32(&mut self, v: u32) -> Result<Ok, Error>
[src]
fn erased_serialize_u64(&mut self, v: u64) -> Result<Ok, Error>
[src]
fn erased_serialize_i128(&mut self, v: i128) -> Result<Ok, Error>
[src]
fn erased_serialize_u128(&mut self, v: u128) -> Result<Ok, Error>
[src]
fn erased_serialize_f32(&mut self, v: f32) -> Result<Ok, Error>
[src]
fn erased_serialize_f64(&mut self, v: f64) -> Result<Ok, Error>
[src]
fn erased_serialize_char(&mut self, v: char) -> Result<Ok, Error>
[src]
fn erased_serialize_str(&mut self, v: &str) -> Result<Ok, Error>
[src]
fn erased_serialize_bytes(&mut self, v: &[u8]) -> Result<Ok, Error>
[src]
fn erased_serialize_none(&mut self) -> Result<Ok, Error>
[src]
fn erased_serialize_some(&mut self, v: &dyn Serialize) -> Result<Ok, Error>
[src]
fn erased_serialize_unit(&mut self) -> Result<Ok, Error>
[src]
fn erased_serialize_unit_struct(
&mut self,
name: &'static str
) -> Result<Ok, Error>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
fn erased_serialize_tuple(&mut self, len: usize) -> Result<Tuple<'_>, Error>
[src]
fn erased_serialize_tuple_struct(
&mut self,
name: &'static str,
len: usize
) -> Result<TupleStruct<'_>, Error>
[src]
&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>
[src]
&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>
[src]
fn erased_serialize_struct(
&mut self,
name: &'static str,
len: usize
) -> Result<Struct<'_>, Error>
[src]
&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>
[src]
&mut self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<StructVariant<'_>, Error>
fn erased_is_human_readable(&self) -> bool
[src]
impl<'a, T: ?Sized + Serializer> Serializer for &'a mut T
[src]
impl<'a, T: ?Sized + Serializer> Serializer for &'a mut T
[src]fn erased_serialize_bool(&mut self, v: bool) -> Result<Ok, Error>
[src]
fn erased_serialize_i8(&mut self, v: i8) -> Result<Ok, Error>
[src]
fn erased_serialize_i16(&mut self, v: i16) -> Result<Ok, Error>
[src]
fn erased_serialize_i32(&mut self, v: i32) -> Result<Ok, Error>
[src]
fn erased_serialize_i64(&mut self, v: i64) -> Result<Ok, Error>
[src]
fn erased_serialize_u8(&mut self, v: u8) -> Result<Ok, Error>
[src]
fn erased_serialize_u16(&mut self, v: u16) -> Result<Ok, Error>
[src]
fn erased_serialize_u32(&mut self, v: u32) -> Result<Ok, Error>
[src]
fn erased_serialize_u64(&mut self, v: u64) -> Result<Ok, Error>
[src]
fn erased_serialize_i128(&mut self, v: i128) -> Result<Ok, Error>
[src]
fn erased_serialize_u128(&mut self, v: u128) -> Result<Ok, Error>
[src]
fn erased_serialize_f32(&mut self, v: f32) -> Result<Ok, Error>
[src]
fn erased_serialize_f64(&mut self, v: f64) -> Result<Ok, Error>
[src]
fn erased_serialize_char(&mut self, v: char) -> Result<Ok, Error>
[src]
fn erased_serialize_str(&mut self, v: &str) -> Result<Ok, Error>
[src]
fn erased_serialize_bytes(&mut self, v: &[u8]) -> Result<Ok, Error>
[src]
fn erased_serialize_none(&mut self) -> Result<Ok, Error>
[src]
fn erased_serialize_some(&mut self, v: &dyn Serialize) -> Result<Ok, Error>
[src]
fn erased_serialize_unit(&mut self) -> Result<Ok, Error>
[src]
fn erased_serialize_unit_struct(
&mut self,
name: &'static str
) -> Result<Ok, Error>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
fn erased_serialize_tuple(&mut self, len: usize) -> Result<Tuple<'_>, Error>
[src]
fn erased_serialize_tuple_struct(
&mut self,
name: &'static str,
len: usize
) -> Result<TupleStruct<'_>, Error>
[src]
&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>
[src]
&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>
[src]
fn erased_serialize_struct(
&mut self,
name: &'static str,
len: usize
) -> Result<Struct<'_>, Error>
[src]
&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>
[src]
&mut self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<StructVariant<'_>, Error>