serde_plain/
ser.rs

Help
1use serde::ser;
2
3use crate::error::Error;
4
5/// A simple serializer that can dump out strings.
6pub struct Serializer;
7
8macro_rules! serialize_as_string {
9    ($($ty:ty => $meth:ident,)*) => {
10        $(fn $meth(self, v: $ty) -> Result<String, Error> { Ok(v.to_string()) })*
11    };
12}
13
14impl ser::Serializer for Serializer {
15    type Ok = String;
16    type Error = Error;
17    type SerializeSeq = ser::Impossible<String, Error>;
18    type SerializeTuple = ser::Impossible<String, Error>;
19    type SerializeTupleStruct = ser::Impossible<String, Error>;
20    type SerializeTupleVariant = ser::Impossible<String, Error>;
21    type SerializeMap = ser::Impossible<String, Error>;
22    type SerializeStruct = ser::Impossible<String, Error>;
23    type SerializeStructVariant = ser::Impossible<String, Error>;
24
25    serialize_as_string! {
26        bool => serialize_bool,
27        u8  => serialize_u8,
28        u16 => serialize_u16,
29        u32 => serialize_u32,
30        u64 => serialize_u64,
31        i8  => serialize_i8,
32        i16 => serialize_i16,
33        i32 => serialize_i32,
34        i64 => serialize_i64,
35        f32 => serialize_f32,
36        f64 => serialize_f64,
37        char => serialize_char,
38        &str => serialize_str,
39    }
40
41    fn serialize_bytes(self, _value: &[u8]) -> Result<String, Error> {
42        Err(Error::ImpossibleSerialization("bytes"))
43    }
44
45    fn serialize_unit(self) -> Result<String, Error> {
46        Ok("".to_string())
47    }
48
49    fn serialize_unit_struct(self, _name: &'static str) -> Result<String, Error> {
50        Err(Error::ImpossibleSerialization("unit struct"))
51    }
52
53    fn serialize_unit_variant(
54        self,
55        _name: &'static str,
56        _variant_index: u32,
57        variant: &'static str,
58    ) -> Result<String, Error> {
59        Ok(variant.to_string())
60    }
61
62    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
63        self,
64        _name: &'static str,
65        value: &T,
66    ) -> Result<String, Error> {
67        value.serialize(self)
68    }
69
70    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
71        self,
72        _name: &'static str,
73        _variant_index: u32,
74        _variant: &'static str,
75        _value: &T,
76    ) -> Result<String, Error> {
77        Err(Error::ImpossibleSerialization("newtype variant"))
78    }
79
80    fn serialize_none(self) -> Result<String, Error> {
81        Ok("".to_string())
82    }
83
84    fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<String, Error> {
85        value.serialize(self)
86    }
87
88    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Error> {
89        Err(Error::ImpossibleSerialization("seq"))
90    }
91
92    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Error> {
93        Err(Error::ImpossibleSerialization("tuple"))
94    }
95
96    fn serialize_tuple_struct(
97        self,
98        _name: &'static str,
99        _len: usize,
100    ) -> Result<Self::SerializeTupleStruct, Error> {
101        Err(Error::ImpossibleSerialization("tuple struct"))
102    }
103
104    fn serialize_tuple_variant(
105        self,
106        _name: &'static str,
107        _variant_index: u32,
108        _variant: &'static str,
109        _len: usize,
110    ) -> Result<Self::SerializeTupleVariant, Error> {
111        Err(Error::ImpossibleSerialization("tuple variant"))
112    }
113
114    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Error> {
115        Err(Error::ImpossibleSerialization("map"))
116    }
117
118    fn serialize_struct(
119        self,
120        _name: &'static str,
121        _len: usize,
122    ) -> Result<Self::SerializeStruct, Error> {
123        Err(Error::ImpossibleSerialization("struct"))
124    }
125
126    fn serialize_struct_variant(
127        self,
128        _name: &'static str,
129        _variant_index: u32,
130        _variant: &'static str,
131        _len: usize,
132    ) -> Result<Self::SerializeStructVariant, Error> {
133        Err(Error::ImpossibleSerialization("struct variant"))
134    }
135}
136
137/// Serialize the given data value as a plain string.
138///
139/// This serializes an object with the `Serializer` into a string and then
140/// returns it.  This requires that the type is a simple one (integer, string,
141/// etc.).
142pub fn to_string<T: ser::Serialize>(value: &T) -> Result<String, Error> {
143    value.serialize(Serializer)
144}
serde_plain/ser.rs

serde_plain/
ser.rs
