ruma_common/canonical_json/
serializer.rs

1#![allow(clippy::exhaustive_structs)]
2
3use std::fmt;
4
5use serde::{
6    de::{Error, Unexpected},
7    ser::{Impossible, Serialize},
8};
9
10use super::{CanonicalJsonError, CanonicalJsonObject, CanonicalJsonValue, to_canonical_value};
11
12/// Type alias for serialization results.
13type Result<T> = std::result::Result<T, CanonicalJsonError>;
14
15/// A [`serde::Serializer`] whose output is a [`CanonicalJsonValue`].
16///
17/// This behaves similarly to [`serde_json::value::Serializer`], except for the following
18/// restrictions which return errors:
19///
20/// - Integers must be in the range accepted by [`js_int::Int`].
21/// - Floats and bytes are not serializable.
22/// - Booleans and integers cannot be used as keys for an object. `serde_json` accepts those types
23///   as keys by serializing them as strings.
24/// - The same key cannot be serialized twice in an object. `serde_json` uses the last value that is
25///   serialized for the same key (at the time of writing).
26pub struct Serializer;
27
28impl serde::Serializer for Serializer {
29    type Ok = CanonicalJsonValue;
30    type Error = CanonicalJsonError;
31
32    type SerializeSeq = SerializeArray;
33    type SerializeTuple = SerializeArray;
34    type SerializeTupleStruct = SerializeArray;
35    type SerializeTupleVariant = SerializeNamedValue<SerializeArray>;
36    type SerializeMap = SerializeObject;
37    type SerializeStruct = SerializeStruct;
38    type SerializeStructVariant = SerializeNamedValue<SerializeObject>;
39
40    #[inline]
41    fn serialize_bool(self, value: bool) -> Result<Self::Ok> {
42        Ok(CanonicalJsonValue::Bool(value))
43    }
44
45    #[inline]
46    fn serialize_i8(self, value: i8) -> Result<Self::Ok> {
47        Ok(CanonicalJsonValue::Integer(value.into()))
48    }
49
50    #[inline]
51    fn serialize_i16(self, value: i16) -> Result<Self::Ok> {
52        Ok(CanonicalJsonValue::Integer(value.into()))
53    }
54
55    #[inline]
56    fn serialize_i32(self, value: i32) -> Result<Self::Ok> {
57        Ok(CanonicalJsonValue::Integer(value.into()))
58    }
59
60    fn serialize_i64(self, value: i64) -> Result<Self::Ok> {
61        Ok(CanonicalJsonValue::Integer(
62            value.try_into().map_err(|_| CanonicalJsonError::IntegerOutOfRange)?,
63        ))
64    }
65
66    fn serialize_i128(self, value: i128) -> Result<Self::Ok> {
67        Ok(CanonicalJsonValue::Integer(
68            value.try_into().map_err(|_| CanonicalJsonError::IntegerOutOfRange)?,
69        ))
70    }
71
72    #[inline]
73    fn serialize_u8(self, value: u8) -> Result<Self::Ok> {
74        Ok(CanonicalJsonValue::Integer(value.into()))
75    }
76
77    #[inline]
78    fn serialize_u16(self, value: u16) -> Result<Self::Ok> {
79        Ok(CanonicalJsonValue::Integer(value.into()))
80    }
81
82    #[inline]
83    fn serialize_u32(self, value: u32) -> Result<Self::Ok> {
84        Ok(CanonicalJsonValue::Integer(value.into()))
85    }
86
87    #[inline]
88    fn serialize_u64(self, value: u64) -> Result<Self::Ok> {
89        Ok(CanonicalJsonValue::Integer(
90            value.try_into().map_err(|_| CanonicalJsonError::IntegerOutOfRange)?,
91        ))
92    }
93
94    fn serialize_u128(self, value: u128) -> Result<Self::Ok> {
95        Ok(CanonicalJsonValue::Integer(
96            value.try_into().map_err(|_| CanonicalJsonError::IntegerOutOfRange)?,
97        ))
98    }
99
100    #[inline]
101    fn serialize_f32(self, _float: f32) -> Result<Self::Ok> {
102        Err(CanonicalJsonError::InvalidType("float".to_owned()))
103    }
104
105    #[inline]
106    fn serialize_f64(self, _float: f64) -> Result<Self::Ok> {
107        Err(CanonicalJsonError::InvalidType("float".to_owned()))
108    }
109
110    #[inline]
111    fn serialize_char(self, value: char) -> Result<Self::Ok> {
112        Ok(CanonicalJsonValue::String(value.into()))
113    }
114
115    #[inline]
116    fn serialize_str(self, value: &str) -> Result<Self::Ok> {
117        Ok(CanonicalJsonValue::String(value.to_owned()))
118    }
119
120    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok> {
121        Err(CanonicalJsonError::InvalidType("bytes".to_owned()))
122    }
123
124    #[inline]
125    fn serialize_unit(self) -> Result<Self::Ok> {
126        Ok(CanonicalJsonValue::Null)
127    }
128
129    #[inline]
130    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
131        // Serialize as `null`.
132        self.serialize_unit()
133    }
134
135    #[inline]
136    fn serialize_unit_variant(
137        self,
138        _name: &'static str,
139        _variant_index: u32,
140        variant: &'static str,
141    ) -> Result<Self::Ok> {
142        // Serialize the name of the variant.
143        self.serialize_str(variant)
144    }
145
146    #[inline]
147    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Self::Ok>
148    where
149        T: ?Sized + Serialize,
150    {
151        // Serialize the inner value.
152        value.serialize(self)
153    }
154
155    fn serialize_newtype_variant<T>(
156        self,
157        _name: &'static str,
158        _variant_index: u32,
159        variant: &'static str,
160        value: &T,
161    ) -> Result<Self::Ok>
162    where
163        T: ?Sized + Serialize,
164    {
165        // Serialize as a `{ variant: value }` object.
166        let mut values = CanonicalJsonObject::new();
167        values.insert(variant.to_owned(), to_canonical_value(value)?);
168        Ok(CanonicalJsonValue::Object(values))
169    }
170
171    #[inline]
172    fn serialize_none(self) -> Result<Self::Ok> {
173        self.serialize_unit()
174    }
175
176    #[inline]
177    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok>
178    where
179        T: ?Sized + Serialize,
180    {
181        value.serialize(self)
182    }
183
184    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
185        // Serialize as an array.
186        Ok(SerializeArray(Vec::with_capacity(len.unwrap_or_default())))
187    }
188
189    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
190        // Serialize as an array.
191        self.serialize_seq(Some(len))
192    }
193
194    fn serialize_tuple_struct(
195        self,
196        _name: &'static str,
197        len: usize,
198    ) -> Result<Self::SerializeTupleStruct> {
199        // Serialize as an array.
200        self.serialize_seq(Some(len))
201    }
202
203    fn serialize_tuple_variant(
204        self,
205        _name: &'static str,
206        _variant_index: u32,
207        variant: &'static str,
208        len: usize,
209    ) -> Result<Self::SerializeTupleVariant> {
210        // Serialize as a `{ variant: [fields…] }` object.
211        Ok(SerializeNamedValue {
212            name: String::from(variant),
213            serialize: self.serialize_tuple(len)?,
214        })
215    }
216
217    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
218        Ok(SerializeObject { object: CanonicalJsonObject::new(), next_key: None })
219    }
220
221    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
222        if name == SerializeStruct::RAW_VALUE_FIELD_NAME {
223            Ok(SerializeStruct::RawValue(None))
224        } else {
225            self.serialize_map(Some(len)).map(SerializeStruct::Object)
226        }
227    }
228
229    fn serialize_struct_variant(
230        self,
231        _name: &'static str,
232        _variant_index: u32,
233        variant: &'static str,
234        len: usize,
235    ) -> Result<Self::SerializeStructVariant> {
236        // Serialize as a `{ variant: { fields… } }` object.
237        Ok(SerializeNamedValue {
238            name: String::from(variant),
239            serialize: self.serialize_map(Some(len))?,
240        })
241    }
242
243    fn collect_str<T>(self, value: &T) -> Result<Self::Ok>
244    where
245        T: ?Sized + fmt::Display,
246    {
247        Ok(CanonicalJsonValue::String(value.to_string()))
248    }
249}
250
251/// Serializer to [`CanonicalJsonValue::Array`].
252pub struct SerializeArray(Vec<CanonicalJsonValue>);
253
254impl serde::ser::SerializeSeq for SerializeArray {
255    type Ok = CanonicalJsonValue;
256    type Error = CanonicalJsonError;
257
258    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
259    where
260        T: ?Sized + Serialize,
261    {
262        self.0.push(to_canonical_value(value)?);
263        Ok(())
264    }
265
266    fn end(self) -> Result<Self::Ok> {
267        Ok(CanonicalJsonValue::Array(self.0))
268    }
269}
270
271impl serde::ser::SerializeTuple for SerializeArray {
272    type Ok = CanonicalJsonValue;
273    type Error = CanonicalJsonError;
274
275    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
276    where
277        T: ?Sized + Serialize,
278    {
279        serde::ser::SerializeSeq::serialize_element(self, value)
280    }
281
282    fn end(self) -> Result<Self::Ok> {
283        serde::ser::SerializeSeq::end(self)
284    }
285}
286
287impl serde::ser::SerializeTupleStruct for SerializeArray {
288    type Ok = CanonicalJsonValue;
289    type Error = CanonicalJsonError;
290
291    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
292    where
293        T: ?Sized + Serialize,
294    {
295        serde::ser::SerializeSeq::serialize_element(self, value)
296    }
297
298    fn end(self) -> Result<Self::Ok> {
299        serde::ser::SerializeSeq::end(self)
300    }
301}
302
303/// Serializer to [`CanonicalJsonValue::Object`].
304pub struct SerializeObject {
305    /// The serialized object.
306    object: CanonicalJsonObject,
307    /// Cache for the key to use for the next value when parsing maps.
308    next_key: Option<String>,
309}
310
311impl serde::ser::SerializeMap for SerializeObject {
312    type Ok = CanonicalJsonValue;
313    type Error = CanonicalJsonError;
314
315    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
316    where
317        T: ?Sized + Serialize,
318    {
319        self.next_key = Some(key.serialize(ObjectKeySerializer)?);
320        Ok(())
321    }
322
323    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
324    where
325        T: ?Sized + Serialize,
326    {
327        // Panic because this indicates a bug in the program rather than an
328        // expected failure.
329        let key = self.next_key.take().expect("serialize_value called before serialize_key");
330
331        if self.object.contains_key(&key) {
332            return Err(CanonicalJsonError::DuplicateObjectKey(key));
333        }
334
335        self.object.insert(key, to_canonical_value(value)?);
336
337        Ok(())
338    }
339
340    fn end(self) -> Result<Self::Ok> {
341        Ok(CanonicalJsonValue::Object(self.object))
342    }
343}
344
345impl serde::ser::SerializeStruct for SerializeObject {
346    type Ok = CanonicalJsonValue;
347    type Error = CanonicalJsonError;
348
349    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
350    where
351        T: ?Sized + Serialize,
352    {
353        serde::ser::SerializeMap::serialize_entry(self, key, value)
354    }
355
356    fn end(self) -> Result<Self::Ok> {
357        serde::ser::SerializeMap::end(self)
358    }
359}
360
361/// Serializer for a [`CanonicalJsonValue`] with a name.
362///
363/// Serializes to [`CanonicalJsonValue::Object`].
364pub struct SerializeNamedValue<V> {
365    /// The name.
366    name: String,
367    /// The value serializer.
368    serialize: V,
369}
370
371impl serde::ser::SerializeTupleVariant for SerializeNamedValue<SerializeArray> {
372    type Ok = CanonicalJsonValue;
373    type Error = CanonicalJsonError;
374
375    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
376    where
377        T: ?Sized + Serialize,
378    {
379        serde::ser::SerializeSeq::serialize_element(&mut self.serialize, value)
380    }
381
382    fn end(self) -> Result<Self::Ok> {
383        let mut object = CanonicalJsonObject::new();
384        object.insert(self.name, serde::ser::SerializeSeq::end(self.serialize)?);
385        Ok(CanonicalJsonValue::Object(object))
386    }
387}
388
389impl serde::ser::SerializeStructVariant for SerializeNamedValue<SerializeObject> {
390    type Ok = CanonicalJsonValue;
391    type Error = CanonicalJsonError;
392
393    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
394    where
395        T: ?Sized + Serialize,
396    {
397        serde::ser::SerializeMap::serialize_entry(&mut self.serialize, key, value)
398    }
399
400    fn end(self) -> Result<Self::Ok> {
401        let mut object = CanonicalJsonObject::new();
402        object.insert(self.name, serde::ser::SerializeMap::end(self.serialize)?);
403        Ok(CanonicalJsonValue::Object(object))
404    }
405}
406
407/// Serializer for the key of a map.
408///
409/// Only accepts strings.
410struct ObjectKeySerializer;
411
412impl serde::Serializer for ObjectKeySerializer {
413    type Ok = String;
414    type Error = CanonicalJsonError;
415
416    type SerializeSeq = Impossible<String, CanonicalJsonError>;
417    type SerializeTuple = Impossible<String, CanonicalJsonError>;
418    type SerializeTupleStruct = Impossible<String, CanonicalJsonError>;
419    type SerializeTupleVariant = Impossible<String, CanonicalJsonError>;
420    type SerializeMap = Impossible<String, CanonicalJsonError>;
421    type SerializeStruct = Impossible<String, CanonicalJsonError>;
422    type SerializeStructVariant = Impossible<String, CanonicalJsonError>;
423
424    #[inline]
425    fn serialize_unit_variant(
426        self,
427        _name: &'static str,
428        _variant_index: u32,
429        variant: &'static str,
430    ) -> Result<Self::Ok> {
431        Ok(variant.to_owned())
432    }
433
434    #[inline]
435    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Self::Ok>
436    where
437        T: ?Sized + Serialize,
438    {
439        value.serialize(self)
440    }
441
442    fn serialize_bool(self, _value: bool) -> Result<Self::Ok> {
443        Err(CanonicalJsonError::InvalidObjectKeyType("bool".to_owned()))
444    }
445
446    fn serialize_i8(self, _value: i8) -> Result<Self::Ok> {
447        Err(CanonicalJsonError::InvalidObjectKeyType("integer".to_owned()))
448    }
449
450    fn serialize_i16(self, _value: i16) -> Result<Self::Ok> {
451        Err(CanonicalJsonError::InvalidObjectKeyType("integer".to_owned()))
452    }
453
454    fn serialize_i32(self, _value: i32) -> Result<Self::Ok> {
455        Err(CanonicalJsonError::InvalidObjectKeyType("integer".to_owned()))
456    }
457
458    fn serialize_i64(self, _value: i64) -> Result<Self::Ok> {
459        Err(CanonicalJsonError::InvalidObjectKeyType("integer".to_owned()))
460    }
461
462    fn serialize_i128(self, _value: i128) -> Result<Self::Ok> {
463        Err(CanonicalJsonError::InvalidObjectKeyType("integer".to_owned()))
464    }
465
466    fn serialize_u8(self, _value: u8) -> Result<Self::Ok> {
467        Err(CanonicalJsonError::InvalidObjectKeyType("integer".to_owned()))
468    }
469
470    fn serialize_u16(self, _value: u16) -> Result<Self::Ok> {
471        Err(CanonicalJsonError::InvalidObjectKeyType("integer".to_owned()))
472    }
473
474    fn serialize_u32(self, _value: u32) -> Result<Self::Ok> {
475        Err(CanonicalJsonError::InvalidObjectKeyType("integer".to_owned()))
476    }
477
478    fn serialize_u64(self, _value: u64) -> Result<Self::Ok> {
479        Err(CanonicalJsonError::InvalidObjectKeyType("integer".to_owned()))
480    }
481
482    fn serialize_u128(self, _value: u128) -> Result<Self::Ok> {
483        Err(CanonicalJsonError::InvalidObjectKeyType("integer".to_owned()))
484    }
485
486    fn serialize_f32(self, _value: f32) -> Result<Self::Ok> {
487        Err(CanonicalJsonError::InvalidType("float".to_owned()))
488    }
489
490    fn serialize_f64(self, _value: f64) -> Result<Self::Ok> {
491        Err(CanonicalJsonError::InvalidType("integer".to_owned()))
492    }
493
494    #[inline]
495    fn serialize_char(self, value: char) -> Result<Self::Ok> {
496        Ok(value.into())
497    }
498
499    #[inline]
500    fn serialize_str(self, value: &str) -> Result<Self::Ok> {
501        Ok(value.to_owned())
502    }
503
504    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok> {
505        Err(CanonicalJsonError::InvalidType("bytes".to_owned()))
506    }
507
508    fn serialize_unit(self) -> Result<Self::Ok> {
509        Err(CanonicalJsonError::InvalidObjectKeyType("()".to_owned()))
510    }
511
512    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok> {
513        Err(CanonicalJsonError::InvalidObjectKeyType(name.to_owned()))
514    }
515
516    fn serialize_newtype_variant<T>(
517        self,
518        name: &'static str,
519        _variant_index: u32,
520        variant: &'static str,
521        _value: &T,
522    ) -> Result<Self::Ok>
523    where
524        T: ?Sized + Serialize,
525    {
526        Err(CanonicalJsonError::InvalidObjectKeyType(format!("{name}::{variant}")))
527    }
528
529    fn serialize_none(self) -> Result<Self::Ok> {
530        Err(CanonicalJsonError::InvalidObjectKeyType("Option".to_owned()))
531    }
532
533    fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok>
534    where
535        T: ?Sized + Serialize,
536    {
537        Err(CanonicalJsonError::InvalidObjectKeyType("Option".to_owned()))
538    }
539
540    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
541        Err(CanonicalJsonError::InvalidObjectKeyType("sequence".to_owned()))
542    }
543
544    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
545        Err(CanonicalJsonError::InvalidObjectKeyType("tuple".to_owned()))
546    }
547
548    fn serialize_tuple_struct(
549        self,
550        name: &'static str,
551        _len: usize,
552    ) -> Result<Self::SerializeTupleStruct> {
553        Err(CanonicalJsonError::InvalidObjectKeyType(name.to_owned()))
554    }
555
556    fn serialize_tuple_variant(
557        self,
558        name: &'static str,
559        _variant_index: u32,
560        variant: &'static str,
561        _len: usize,
562    ) -> Result<Self::SerializeTupleVariant> {
563        Err(CanonicalJsonError::InvalidObjectKeyType(format!("{name}::{variant}")))
564    }
565
566    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
567        Err(CanonicalJsonError::InvalidObjectKeyType("map".to_owned()))
568    }
569
570    fn serialize_struct(self, name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
571        Err(CanonicalJsonError::InvalidObjectKeyType(name.to_owned()))
572    }
573
574    fn serialize_struct_variant(
575        self,
576        name: &'static str,
577        _variant_index: u32,
578        variant: &'static str,
579        _len: usize,
580    ) -> Result<Self::SerializeStructVariant> {
581        Err(CanonicalJsonError::InvalidObjectKeyType(format!("{name}::{variant}")))
582    }
583
584    fn collect_str<T>(self, value: &T) -> Result<Self::Ok>
585    where
586        T: ?Sized + fmt::Display,
587    {
588        Ok(value.to_string())
589    }
590}
591
592/// Serializer for a struct.
593///
594/// If the struct is a [`serde_json::value::RawValue`], it is deserialized to a
595/// [`CanonicalJsonValue`]. Other structs are serialized as objects.
596pub enum SerializeStruct {
597    /// Serialize a [`serde_json::value::RawValue`].
598    ///
599    /// Will contain the deserialized value.
600    RawValue(Option<CanonicalJsonValue>),
601
602    /// Serialize an object.
603    Object(SerializeObject),
604}
605
606impl SerializeStruct {
607    /// The hardcoded name of the field used by `serde_json` to detect a `RawValue`.
608    // source: https://github.com/serde-rs/json/blob/4f6dbfac79647d032b0997b5ab73022340c6dab7/src/raw.rs#L299
609    const RAW_VALUE_FIELD_NAME: &str = "$serde_json::private::RawValue";
610}
611
612impl serde::ser::SerializeStruct for SerializeStruct {
613    type Ok = CanonicalJsonValue;
614    type Error = CanonicalJsonError;
615
616    fn serialize_field<T>(
617        &mut self,
618        key: &'static str,
619        value: &T,
620    ) -> std::result::Result<(), Self::Error>
621    where
622        T: ?Sized + Serialize,
623    {
624        match self {
625            Self::RawValue(deserialized) => {
626                *deserialized = Some(value.serialize(RawValueSerializer)?);
627                Ok(())
628            }
629            Self::Object(serialize) => {
630                serde::ser::SerializeMap::serialize_entry(serialize, key, value)
631            }
632        }
633    }
634
635    fn end(self) -> std::result::Result<Self::Ok, Self::Error> {
636        match self {
637            Self::RawValue(deserialized) => {
638                Ok(deserialized.expect("RawValue should have been deserialized"))
639            }
640            Self::Object(serialize) => serde::ser::SerializeMap::end(serialize),
641        }
642    }
643}
644
645/// A re-serializer for a [`serde_json::value::RawValue`].
646struct RawValueSerializer;
647
648impl serde::ser::Serializer for RawValueSerializer {
649    type Ok = CanonicalJsonValue;
650    type Error = CanonicalJsonError;
651
652    type SerializeSeq = Impossible<CanonicalJsonValue, CanonicalJsonError>;
653    type SerializeTuple = Impossible<CanonicalJsonValue, CanonicalJsonError>;
654    type SerializeTupleStruct = Impossible<CanonicalJsonValue, CanonicalJsonError>;
655    type SerializeTupleVariant = Impossible<CanonicalJsonValue, CanonicalJsonError>;
656    type SerializeMap = Impossible<CanonicalJsonValue, CanonicalJsonError>;
657    type SerializeStruct = Impossible<CanonicalJsonValue, CanonicalJsonError>;
658    type SerializeStructVariant = Impossible<CanonicalJsonValue, CanonicalJsonError>;
659
660    fn serialize_bool(self, v: bool) -> Result<CanonicalJsonValue> {
661        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
662            Unexpected::Bool(v),
663            &"raw value",
664        )))
665    }
666
667    fn serialize_i8(self, v: i8) -> Result<CanonicalJsonValue> {
668        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
669            Unexpected::Signed(v.into()),
670            &"raw value",
671        )))
672    }
673
674    fn serialize_i16(self, v: i16) -> Result<CanonicalJsonValue> {
675        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
676            Unexpected::Signed(v.into()),
677            &"raw value",
678        )))
679    }
680
681    fn serialize_i32(self, v: i32) -> Result<CanonicalJsonValue> {
682        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
683            Unexpected::Signed(v.into()),
684            &"raw value",
685        )))
686    }
687
688    fn serialize_i64(self, v: i64) -> Result<CanonicalJsonValue> {
689        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
690            Unexpected::Signed(v),
691            &"raw value",
692        )))
693    }
694
695    fn serialize_u8(self, v: u8) -> Result<CanonicalJsonValue> {
696        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
697            Unexpected::Unsigned(v.into()),
698            &"raw value",
699        )))
700    }
701
702    fn serialize_u16(self, v: u16) -> Result<CanonicalJsonValue> {
703        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
704            Unexpected::Unsigned(v.into()),
705            &"raw value",
706        )))
707    }
708
709    fn serialize_u32(self, v: u32) -> Result<CanonicalJsonValue> {
710        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
711            Unexpected::Unsigned(v.into()),
712            &"raw value",
713        )))
714    }
715
716    fn serialize_u64(self, v: u64) -> Result<CanonicalJsonValue> {
717        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
718            Unexpected::Unsigned(v),
719            &"raw value",
720        )))
721    }
722
723    fn serialize_f32(self, v: f32) -> Result<CanonicalJsonValue> {
724        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
725            Unexpected::Float(v.into()),
726            &"raw value",
727        )))
728    }
729
730    fn serialize_f64(self, v: f64) -> Result<CanonicalJsonValue> {
731        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
732            Unexpected::Float(v),
733            &"raw value",
734        )))
735    }
736
737    fn serialize_char(self, v: char) -> Result<CanonicalJsonValue> {
738        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
739            Unexpected::Char(v),
740            &"raw value",
741        )))
742    }
743
744    fn serialize_str(self, value: &str) -> Result<CanonicalJsonValue> {
745        serde_json::from_str(value).map_err(CanonicalJsonError::InvalidRawValue)
746    }
747
748    fn serialize_bytes(self, v: &[u8]) -> Result<CanonicalJsonValue> {
749        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
750            Unexpected::Bytes(v),
751            &"raw value",
752        )))
753    }
754
755    fn serialize_none(self) -> Result<CanonicalJsonValue> {
756        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
757            Unexpected::Other("`None`"),
758            &"raw value",
759        )))
760    }
761
762    fn serialize_some<T>(self, _v: &T) -> Result<CanonicalJsonValue>
763    where
764        T: ?Sized + Serialize,
765    {
766        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
767            Unexpected::Other("`Some(_)`"),
768            &"raw value",
769        )))
770    }
771
772    fn serialize_unit(self) -> Result<CanonicalJsonValue> {
773        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
774            Unexpected::Unit,
775            &"raw value",
776        )))
777    }
778
779    fn serialize_unit_struct(self, _name: &'static str) -> Result<CanonicalJsonValue> {
780        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
781            Unexpected::Other("unit struct"),
782            &"raw value",
783        )))
784    }
785
786    fn serialize_unit_variant(
787        self,
788        _name: &'static str,
789        _variant_index: u32,
790        _variant: &'static str,
791    ) -> Result<CanonicalJsonValue> {
792        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
793            Unexpected::UnitVariant,
794            &"raw value",
795        )))
796    }
797
798    fn serialize_newtype_struct<T>(
799        self,
800        _name: &'static str,
801        _value: &T,
802    ) -> Result<CanonicalJsonValue>
803    where
804        T: ?Sized + Serialize,
805    {
806        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
807            Unexpected::NewtypeStruct,
808            &"raw value",
809        )))
810    }
811
812    fn serialize_newtype_variant<T>(
813        self,
814        _name: &'static str,
815        _variant_index: u32,
816        _variant: &'static str,
817        _value: &T,
818    ) -> Result<CanonicalJsonValue>
819    where
820        T: ?Sized + Serialize,
821    {
822        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
823            Unexpected::NewtypeVariant,
824            &"raw value",
825        )))
826    }
827
828    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
829        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
830            Unexpected::Seq,
831            &"raw value",
832        )))
833    }
834
835    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
836        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
837            Unexpected::Other("tuple"),
838            &"raw value",
839        )))
840    }
841
842    fn serialize_tuple_struct(
843        self,
844        _name: &'static str,
845        _len: usize,
846    ) -> Result<Self::SerializeTupleStruct> {
847        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
848            Unexpected::Other("tuple struct"),
849            &"raw value",
850        )))
851    }
852
853    fn serialize_tuple_variant(
854        self,
855        _name: &'static str,
856        _variant_index: u32,
857        _variant: &'static str,
858        _len: usize,
859    ) -> Result<Self::SerializeTupleVariant> {
860        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
861            Unexpected::TupleVariant,
862            &"raw value",
863        )))
864    }
865
866    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
867        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
868            Unexpected::Map,
869            &"raw value",
870        )))
871    }
872
873    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
874        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
875            Unexpected::Other("struct"),
876            &"raw value",
877        )))
878    }
879
880    fn serialize_struct_variant(
881        self,
882        _name: &'static str,
883        _variant_index: u32,
884        _variant: &'static str,
885        _len: usize,
886    ) -> Result<Self::SerializeStructVariant> {
887        Err(CanonicalJsonError::InvalidRawValue(serde_json::Error::invalid_type(
888            Unexpected::StructVariant,
889            &"raw value",
890        )))
891    }
892
893    fn collect_str<T>(self, value: &T) -> Result<Self::Ok>
894    where
895        T: ?Sized + fmt::Display,
896    {
897        self.serialize_str(&value.to_string())
898    }
899}
ruma_common/canonical_json/serializer.rs

ruma_common/canonical_json/
serializer.rs
