Struct serde_json_v8::value::Serializer [−][src]
pub struct Serializer;
Serializer whose output is a Value
.
This is the serializer that backs serde_json::to_value
.
Unlike the main serde_json serializer which goes from some serializable
value of type T
to JSON text, this one goes from T
to
serde_json::Value
.
The to_value
function is implementable as:
use serde::Serialize; use serde_json::{Error, Value}; pub fn to_value<T>(input: T) -> Result<Value, Error> where T: Serialize, { input.serialize(serde_json::value::Serializer) }
Trait Implementations
impl Serializer for Serializer
[src]
impl Serializer for Serializer
[src]type Ok = Value
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 = SerializeVec
Type returned from serialize_seq
for serializing the content of the
sequence. Read more
type SerializeTuple = SerializeVec
Type returned from serialize_tuple
for serializing the content of
the tuple. Read more
type SerializeTupleStruct = SerializeVec
Type returned from serialize_tuple_struct
for serializing the
content of the tuple struct. Read more
type SerializeTupleVariant = SerializeTupleVariant
Type returned from serialize_tuple_variant
for serializing the
content of the tuple variant. Read more
type SerializeMap = SerializeMap
Type returned from serialize_map
for serializing the content of the
map. Read more
type SerializeStruct = SerializeMap
Type returned from serialize_struct
for serializing the content of
the struct. Read more
type SerializeStructVariant = SerializeStructVariant
Type returned from serialize_struct_variant
for serializing the
content of the struct variant. Read more
pub fn serialize_bool(self, value: bool) -> Result<Value, Error>
[src]
pub fn serialize_i8(self, value: i8) -> Result<Value, Error>
[src]
pub fn serialize_i16(self, value: i16) -> Result<Value, Error>
[src]
pub fn serialize_i32(self, value: i32) -> Result<Value, Error>
[src]
pub fn serialize_i64(self, value: i64) -> Result<Value, Error>
[src]
pub fn serialize_u8(self, value: u8) -> Result<Value, Error>
[src]
pub fn serialize_u16(self, value: u16) -> Result<Value, Error>
[src]
pub fn serialize_u32(self, value: u32) -> Result<Value, Error>
[src]
pub fn serialize_u64(self, value: u64) -> Result<Value, Error>
[src]
pub fn serialize_f32(self, value: f32) -> Result<Value, Error>
[src]
pub fn serialize_f64(self, value: f64) -> Result<Value, Error>
[src]
pub fn serialize_char(self, value: char) -> Result<Value, Error>
[src]
pub fn serialize_str(self, value: &str) -> Result<Value, Error>
[src]
pub fn serialize_bytes(self, value: &[u8]) -> Result<Value, Error>
[src]
pub fn serialize_unit(self) -> Result<Value, Error>
[src]
pub fn serialize_unit_struct(self, _name: &'static str) -> Result<Value, Error>
[src]
pub fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str
) -> Result<Value, Error>
[src]
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str
) -> Result<Value, Error>
pub fn serialize_newtype_struct<T>(
self,
_name: &'static str,
value: &T
) -> Result<Value, Error> where
T: Serialize + ?Sized,
[src]
self,
_name: &'static str,
value: &T
) -> Result<Value, Error> where
T: Serialize + ?Sized,
pub fn serialize_newtype_variant<T>(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
value: &T
) -> Result<Value, Error> where
T: Serialize + ?Sized,
[src]
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
value: &T
) -> Result<Value, Error> where
T: Serialize + ?Sized,
pub fn serialize_none(self) -> Result<Value, Error>
[src]
pub fn serialize_some<T>(self, value: &T) -> Result<Value, Error> where
T: Serialize + ?Sized,
[src]
T: Serialize + ?Sized,
pub fn serialize_seq(
self,
len: Option<usize>
) -> Result<<Serializer as Serializer>::SerializeSeq, Error>
[src]
self,
len: Option<usize>
) -> Result<<Serializer as Serializer>::SerializeSeq, Error>
pub fn serialize_tuple(
self,
len: usize
) -> Result<<Serializer as Serializer>::SerializeTuple, Error>
[src]
self,
len: usize
) -> Result<<Serializer as Serializer>::SerializeTuple, Error>
pub fn serialize_tuple_struct(
self,
_name: &'static str,
len: usize
) -> Result<<Serializer as Serializer>::SerializeTupleStruct, Error>
[src]
self,
_name: &'static str,
len: usize
) -> Result<<Serializer as Serializer>::SerializeTupleStruct, Error>
pub fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
len: usize
) -> Result<<Serializer as Serializer>::SerializeTupleVariant, Error>
[src]
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
len: usize
) -> Result<<Serializer as Serializer>::SerializeTupleVariant, Error>
pub fn serialize_map(
self,
_len: Option<usize>
) -> Result<<Serializer as Serializer>::SerializeMap, Error>
[src]
self,
_len: Option<usize>
) -> Result<<Serializer as Serializer>::SerializeMap, Error>
pub fn serialize_struct(
self,
name: &'static str,
len: usize
) -> Result<<Serializer as Serializer>::SerializeStruct, Error>
[src]
self,
name: &'static str,
len: usize
) -> Result<<Serializer as Serializer>::SerializeStruct, Error>
pub fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
_len: usize
) -> Result<<Serializer as Serializer>::SerializeStructVariant, Error>
[src]
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
_len: usize
) -> Result<<Serializer as Serializer>::SerializeStructVariant, Error>
pub fn collect_str<T>(self, value: &T) -> Result<Value, Error> where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
pub fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error>
[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
K: Serialize,
V: Serialize,
I: IntoIterator<Item = (K, V)>,
[src]
K: Serialize,
V: Serialize,
I: IntoIterator<Item = (K, V)>,
pub fn is_human_readable(&self) -> bool
[src]
Auto Trait Implementations
impl RefUnwindSafe for Serializer
impl RefUnwindSafe for Serializer
impl Send for Serializer
impl Send for Serializer
impl Sync for Serializer
impl Sync for Serializer
impl Unpin for Serializer
impl Unpin for Serializer
impl UnwindSafe for Serializer
impl UnwindSafe for Serializer