json_web_tolkien/
ser.rs

1use base64ct::{Base64UrlUnpadded, Encoding};
2use serde::{Serialize, ser};
3
4use crate::error::Error;
5
6pub struct Serializer {
7    pub output: String,
8}
9
10impl ser::Serializer for &mut Serializer {
11    type Ok = ();
12    type Error = Error;
13    type SerializeSeq = Self;
14    type SerializeTuple = Self;
15    type SerializeTupleStruct = Self;
16    type SerializeTupleVariant = Self;
17    type SerializeMap = Self;
18    type SerializeStruct = Self;
19    type SerializeStructVariant = Self;
20
21    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
22        let v: String = Base64UrlUnpadded::encode_string(v);
23
24        self.output += v.as_str();
25
26        Ok(())
27    }
28
29    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
30        Ok(())
31    }
32
33    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
34    where
35        T: ?Sized + Serialize,
36    {
37        value.serialize(self)
38    }
39
40    fn serialize_newtype_struct<T>(
41        self,
42        _: &'static str,
43        value: &T,
44    ) -> Result<Self::Ok, Self::Error>
45    where
46        T: ?Sized + Serialize,
47    {
48        value.serialize(self)
49    }
50
51    fn serialize_newtype_variant<T>(
52        self,
53        _: &'static str,
54        _: u32,
55        _: &'static str,
56        value: &T,
57    ) -> Result<Self::Ok, Self::Error>
58    where
59        T: ?Sized + Serialize,
60    {
61        value.serialize(self)
62    }
63
64    fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
65        Ok(self)
66    }
67
68    fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
69        Ok(self)
70    }
71
72    fn serialize_tuple_struct(
73        self,
74        _: &'static str,
75        _: usize,
76    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
77        Ok(self)
78    }
79
80    fn serialize_tuple_variant(
81        self,
82        _: &'static str,
83        _: u32,
84        _: &'static str,
85        _: usize,
86    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
87        Ok(self)
88    }
89
90    /// If this is already a string then just add it to the output.
91    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
92        self.output += v;
93
94        Ok(())
95    }
96
97    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
98        Ok(())
99    }
100
101    fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
102        Err(Error::UnexpectedTypeBool)
103    }
104
105    fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
106        Err(Error::UnexpectedTypeChar)
107    }
108
109    fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
110        Err(Error::UnexpectedTypeFloat)
111    }
112
113    fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
114        Err(Error::UnexpectedTypeFloat)
115    }
116    fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
117        Err(Error::UnexpectedTypeInteger)
118    }
119
120    fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
121        Err(Error::UnexpectedTypeInteger)
122    }
123
124    fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
125        Err(Error::UnexpectedTypeInteger)
126    }
127
128    fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
129        Err(Error::UnexpectedTypeInteger)
130    }
131
132    fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
133        Err(Error::UnableToDetermineElementOrder)
134    }
135
136    fn serialize_struct(
137        self,
138        _: &'static str,
139        _: usize,
140    ) -> Result<Self::SerializeStruct, Self::Error> {
141        Err(Error::UnableToDetermineElementOrder)
142    }
143
144    fn serialize_struct_variant(
145        self,
146        _: &'static str,
147        _: u32,
148        _: &'static str,
149        _: usize,
150    ) -> Result<Self::SerializeStructVariant, Self::Error> {
151        Err(Error::UnableToDetermineElementOrder)
152    }
153
154    fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
155        Err(Error::UnexpectedTypeInteger)
156    }
157
158    fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
159        Err(Error::UnexpectedTypeInteger)
160    }
161
162    fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
163        Err(Error::UnexpectedTypeInteger)
164    }
165
166    fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
167        Err(Error::UnexpectedTypeInteger)
168    }
169
170    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
171        Err(Error::UnexpectedEmptyType)
172    }
173
174    fn serialize_unit_variant(
175        self,
176        _: &'static str,
177        _: u32,
178        _: &'static str,
179    ) -> Result<Self::Ok, Self::Error> {
180        Err(Error::UnexpectedEmptyType)
181    }
182}
183
184impl ser::SerializeSeq for &mut Serializer {
185    type Ok = ();
186
187    type Error = Error;
188
189    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
190    where
191        T: ?Sized + Serialize,
192    {
193        if !self.output.is_empty() && !self.output.ends_with('.') {
194            self.output += ".";
195        }
196
197        value.serialize(&mut **self)
198    }
199
200    fn end(self) -> Result<Self::Ok, Self::Error> {
201        Ok(())
202    }
203}
204
205impl ser::SerializeMap for &mut Serializer {
206    type Ok = ();
207    type Error = Error;
208
209    fn end(self) -> Result<Self::Ok, Self::Error> {
210        Err(Error::UnableToDetermineElementOrder)
211    }
212
213    fn serialize_key<T>(&mut self, _: &T) -> Result<(), Self::Error>
214    where
215        T: ?Sized + Serialize,
216    {
217        Err(Error::UnableToDetermineElementOrder)
218    }
219
220    fn serialize_value<T>(&mut self, _: &T) -> Result<(), Self::Error>
221    where
222        T: ?Sized + Serialize,
223    {
224        Err(Error::UnableToDetermineElementOrder)
225    }
226}
227
228impl ser::SerializeStruct for &mut Serializer {
229    type Ok = ();
230    type Error = Error;
231
232    fn end(self) -> Result<Self::Ok, Self::Error> {
233        Err(Error::UnableToDetermineElementOrder)
234    }
235
236    fn serialize_field<T>(&mut self, _: &'static str, _: &T) -> Result<(), Self::Error>
237    where
238        T: ?Sized + Serialize,
239    {
240        Err(Error::UnableToDetermineElementOrder)
241    }
242}
243
244impl ser::SerializeStructVariant for &mut Serializer {
245    type Ok = ();
246    type Error = Error;
247
248    fn end(self) -> Result<Self::Ok, Self::Error> {
249        Err(Error::UnableToDetermineElementOrder)
250    }
251
252    fn serialize_field<T>(&mut self, _: &'static str, _: &T) -> Result<(), Self::Error>
253    where
254        T: ?Sized + Serialize,
255    {
256        Err(Error::UnableToDetermineElementOrder)
257    }
258}
259
260impl ser::SerializeTuple for &mut Serializer {
261    type Ok = ();
262
263    type Error = Error;
264
265    fn end(self) -> Result<Self::Ok, Self::Error> {
266        Ok(())
267    }
268
269    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
270    where
271        T: ?Sized + Serialize,
272    {
273        if !self.output.is_empty() && !self.output.ends_with('.') {
274            self.output += ".";
275        }
276
277        value.serialize(&mut **self)
278    }
279}
280
281impl ser::SerializeTupleStruct for &mut Serializer {
282    type Ok = ();
283    type Error = Error;
284
285    fn end(self) -> Result<Self::Ok, Self::Error> {
286        Ok(())
287    }
288
289    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
290    where
291        T: ?Sized + Serialize,
292    {
293        if !self.output.is_empty() && !self.output.ends_with('.') {
294            self.output += ".";
295        }
296
297        value.serialize(&mut **self)
298    }
299}
300
301impl ser::SerializeTupleVariant for &mut Serializer {
302    type Ok = ();
303    type Error = Error;
304
305    fn end(self) -> Result<Self::Ok, Self::Error> {
306        Ok(())
307    }
308
309    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
310    where
311        T: ?Sized + Serialize,
312    {
313        if !self.output.is_empty() && !self.output.ends_with('.') {
314            self.output += ".";
315        }
316
317        value.serialize(&mut **self)
318    }
319}
json_web_tolkien/ser.rs

json_web_tolkien/
ser.rs
