serde_json/value/
ser.rs

1use crate::error::{Error, ErrorCode, Result};
2use crate::map::Map;
3use crate::value::{to_value, Value};
4use alloc::borrow::ToOwned;
5use alloc::string::{String, ToString};
6use alloc::vec::Vec;
7use core::fmt::Display;
8use core::result;
9use serde::ser::{Impossible, Serialize};
10
11impl Serialize for Value {
12    #[inline]
13    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
14    where
15        S: ::serde::Serializer,
16    {
17        match self {
18            Value::Null => serializer.serialize_unit(),
19            Value::Bool(b) => serializer.serialize_bool(*b),
20            Value::Number(n) => n.serialize(serializer),
21            Value::String(s) => serializer.serialize_str(s),
22            Value::Array(v) => v.serialize(serializer),
23            #[cfg(any(feature = "std", feature = "alloc"))]
24            Value::Object(m) => {
25                use serde::ser::SerializeMap;
26                let mut map = tri!(serializer.serialize_map(Some(m.len())));
27                for (k, v) in m {
28                    tri!(map.serialize_entry(k, v));
29                }
30                map.end()
31            }
32        }
33    }
34}
35
36/// Serializer whose output is a `Value`.
37///
38/// This is the serializer that backs [`serde_json::to_value`][crate::to_value].
39/// Unlike the main serde_json serializer which goes from some serializable
40/// value of type `T` to JSON text, this one goes from `T` to
41/// `serde_json::Value`.
42///
43/// The `to_value` function is implementable as:
44///
45/// ```
46/// use serde::Serialize;
47/// use serde_json::{Error, Value};
48///
49/// pub fn to_value<T>(input: T) -> Result<Value, Error>
50/// where
51///     T: Serialize,
52/// {
53///     input.serialize(serde_json::value::Serializer)
54/// }
55/// ```
56pub struct Serializer;
57
58impl serde::Serializer for Serializer {
59    type Ok = Value;
60    type Error = Error;
61
62    type SerializeSeq = SerializeVec;
63    type SerializeTuple = SerializeVec;
64    type SerializeTupleStruct = SerializeVec;
65    type SerializeTupleVariant = SerializeTupleVariant;
66    type SerializeMap = SerializeMap;
67    type SerializeStruct = SerializeMap;
68    type SerializeStructVariant = SerializeStructVariant;
69
70    #[inline]
71    fn serialize_bool(self, value: bool) -> Result<Value> {
72        Ok(Value::Bool(value))
73    }
74
75    #[inline]
76    fn serialize_i8(self, value: i8) -> Result<Value> {
77        self.serialize_i64(value as i64)
78    }
79
80    #[inline]
81    fn serialize_i16(self, value: i16) -> Result<Value> {
82        self.serialize_i64(value as i64)
83    }
84
85    #[inline]
86    fn serialize_i32(self, value: i32) -> Result<Value> {
87        self.serialize_i64(value as i64)
88    }
89
90    fn serialize_i64(self, value: i64) -> Result<Value> {
91        Ok(Value::Number(value.into()))
92    }
93
94    fn serialize_i128(self, value: i128) -> Result<Value> {
95        #[cfg(feature = "arbitrary_precision")]
96        {
97            Ok(Value::Number(value.into()))
98        }
99
100        #[cfg(not(feature = "arbitrary_precision"))]
101        {
102            if let Ok(value) = u64::try_from(value) {
103                Ok(Value::Number(value.into()))
104            } else if let Ok(value) = i64::try_from(value) {
105                Ok(Value::Number(value.into()))
106            } else {
107                Err(Error::syntax(ErrorCode::NumberOutOfRange, 0, 0))
108            }
109        }
110    }
111
112    #[inline]
113    fn serialize_u8(self, value: u8) -> Result<Value> {
114        self.serialize_u64(value as u64)
115    }
116
117    #[inline]
118    fn serialize_u16(self, value: u16) -> Result<Value> {
119        self.serialize_u64(value as u64)
120    }
121
122    #[inline]
123    fn serialize_u32(self, value: u32) -> Result<Value> {
124        self.serialize_u64(value as u64)
125    }
126
127    #[inline]
128    fn serialize_u64(self, value: u64) -> Result<Value> {
129        Ok(Value::Number(value.into()))
130    }
131
132    fn serialize_u128(self, value: u128) -> Result<Value> {
133        #[cfg(feature = "arbitrary_precision")]
134        {
135            Ok(Value::Number(value.into()))
136        }
137
138        #[cfg(not(feature = "arbitrary_precision"))]
139        {
140            if let Ok(value) = u64::try_from(value) {
141                Ok(Value::Number(value.into()))
142            } else {
143                Err(Error::syntax(ErrorCode::NumberOutOfRange, 0, 0))
144            }
145        }
146    }
147
148    #[inline]
149    fn serialize_f32(self, float: f32) -> Result<Value> {
150        Ok(Value::from(float))
151    }
152
153    #[inline]
154    fn serialize_f64(self, float: f64) -> Result<Value> {
155        Ok(Value::from(float))
156    }
157
158    #[inline]
159    fn serialize_char(self, value: char) -> Result<Value> {
160        let mut s = String::new();
161        s.push(value);
162        Ok(Value::String(s))
163    }
164
165    #[inline]
166    fn serialize_str(self, value: &str) -> Result<Value> {
167        Ok(Value::String(value.to_owned()))
168    }
169
170    fn serialize_bytes(self, value: &[u8]) -> Result<Value> {
171        let vec = value.iter().map(|&b| Value::Number(b.into())).collect();
172        Ok(Value::Array(vec))
173    }
174
175    #[inline]
176    fn serialize_unit(self) -> Result<Value> {
177        Ok(Value::Null)
178    }
179
180    #[inline]
181    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
182        self.serialize_unit()
183    }
184
185    #[inline]
186    fn serialize_unit_variant(
187        self,
188        _name: &'static str,
189        _variant_index: u32,
190        variant: &'static str,
191    ) -> Result<Value> {
192        self.serialize_str(variant)
193    }
194
195    #[inline]
196    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Value>
197    where
198        T: ?Sized + Serialize,
199    {
200        value.serialize(self)
201    }
202
203    fn serialize_newtype_variant<T>(
204        self,
205        _name: &'static str,
206        _variant_index: u32,
207        variant: &'static str,
208        value: &T,
209    ) -> Result<Value>
210    where
211        T: ?Sized + Serialize,
212    {
213        let mut values = Map::new();
214        values.insert(String::from(variant), tri!(to_value(value)));
215        Ok(Value::Object(values))
216    }
217
218    #[inline]
219    fn serialize_none(self) -> Result<Value> {
220        self.serialize_unit()
221    }
222
223    #[inline]
224    fn serialize_some<T>(self, value: &T) -> Result<Value>
225    where
226        T: ?Sized + Serialize,
227    {
228        value.serialize(self)
229    }
230
231    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
232        Ok(SerializeVec {
233            vec: Vec::with_capacity(len.unwrap_or(0)),
234        })
235    }
236
237    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
238        self.serialize_seq(Some(len))
239    }
240
241    fn serialize_tuple_struct(
242        self,
243        _name: &'static str,
244        len: usize,
245    ) -> Result<Self::SerializeTupleStruct> {
246        self.serialize_seq(Some(len))
247    }
248
249    fn serialize_tuple_variant(
250        self,
251        _name: &'static str,
252        _variant_index: u32,
253        variant: &'static str,
254        len: usize,
255    ) -> Result<Self::SerializeTupleVariant> {
256        Ok(SerializeTupleVariant {
257            name: String::from(variant),
258            vec: Vec::with_capacity(len),
259        })
260    }
261
262    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
263        Ok(SerializeMap::Map {
264            map: Map::new(),
265            next_key: None,
266        })
267    }
268
269    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
270        match name {
271            #[cfg(feature = "arbitrary_precision")]
272            crate::number::TOKEN => Ok(SerializeMap::Number { out_value: None }),
273            #[cfg(feature = "raw_value")]
274            crate::raw::TOKEN => Ok(SerializeMap::RawValue { out_value: None }),
275            _ => self.serialize_map(Some(len)),
276        }
277    }
278
279    fn serialize_struct_variant(
280        self,
281        _name: &'static str,
282        _variant_index: u32,
283        variant: &'static str,
284        _len: usize,
285    ) -> Result<Self::SerializeStructVariant> {
286        Ok(SerializeStructVariant {
287            name: String::from(variant),
288            map: Map::new(),
289        })
290    }
291
292    fn collect_str<T>(self, value: &T) -> Result<Value>
293    where
294        T: ?Sized + Display,
295    {
296        Ok(Value::String(value.to_string()))
297    }
298}
299
300pub struct SerializeVec {
301    vec: Vec<Value>,
302}
303
304pub struct SerializeTupleVariant {
305    name: String,
306    vec: Vec<Value>,
307}
308
309pub enum SerializeMap {
310    Map {
311        map: Map<String, Value>,
312        next_key: Option<String>,
313    },
314    #[cfg(feature = "arbitrary_precision")]
315    Number { out_value: Option<Value> },
316    #[cfg(feature = "raw_value")]
317    RawValue { out_value: Option<Value> },
318}
319
320pub struct SerializeStructVariant {
321    name: String,
322    map: Map<String, Value>,
323}
324
325impl serde::ser::SerializeSeq for SerializeVec {
326    type Ok = Value;
327    type Error = Error;
328
329    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
330    where
331        T: ?Sized + Serialize,
332    {
333        self.vec.push(tri!(to_value(value)));
334        Ok(())
335    }
336
337    fn end(self) -> Result<Value> {
338        Ok(Value::Array(self.vec))
339    }
340}
341
342impl serde::ser::SerializeTuple for SerializeVec {
343    type Ok = Value;
344    type Error = Error;
345
346    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
347    where
348        T: ?Sized + Serialize,
349    {
350        serde::ser::SerializeSeq::serialize_element(self, value)
351    }
352
353    fn end(self) -> Result<Value> {
354        serde::ser::SerializeSeq::end(self)
355    }
356}
357
358impl serde::ser::SerializeTupleStruct for SerializeVec {
359    type Ok = Value;
360    type Error = Error;
361
362    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
363    where
364        T: ?Sized + Serialize,
365    {
366        serde::ser::SerializeSeq::serialize_element(self, value)
367    }
368
369    fn end(self) -> Result<Value> {
370        serde::ser::SerializeSeq::end(self)
371    }
372}
373
374impl serde::ser::SerializeTupleVariant for SerializeTupleVariant {
375    type Ok = Value;
376    type Error = Error;
377
378    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
379    where
380        T: ?Sized + Serialize,
381    {
382        self.vec.push(tri!(to_value(value)));
383        Ok(())
384    }
385
386    fn end(self) -> Result<Value> {
387        let mut object = Map::new();
388
389        object.insert(self.name, Value::Array(self.vec));
390
391        Ok(Value::Object(object))
392    }
393}
394
395impl serde::ser::SerializeMap for SerializeMap {
396    type Ok = Value;
397    type Error = Error;
398
399    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
400    where
401        T: ?Sized + Serialize,
402    {
403        match self {
404            SerializeMap::Map { next_key, .. } => {
405                *next_key = Some(tri!(key.serialize(MapKeySerializer)));
406                Ok(())
407            }
408            #[cfg(feature = "arbitrary_precision")]
409            SerializeMap::Number { .. } => unreachable!(),
410            #[cfg(feature = "raw_value")]
411            SerializeMap::RawValue { .. } => unreachable!(),
412        }
413    }
414
415    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
416    where
417        T: ?Sized + Serialize,
418    {
419        match self {
420            SerializeMap::Map { map, next_key } => {
421                let key = next_key.take();
422                // Panic because this indicates a bug in the program rather than an
423                // expected failure.
424                let key = key.expect("serialize_value called before serialize_key");
425                map.insert(key, tri!(to_value(value)));
426                Ok(())
427            }
428            #[cfg(feature = "arbitrary_precision")]
429            SerializeMap::Number { .. } => unreachable!(),
430            #[cfg(feature = "raw_value")]
431            SerializeMap::RawValue { .. } => unreachable!(),
432        }
433    }
434
435    fn end(self) -> Result<Value> {
436        match self {
437            SerializeMap::Map { map, .. } => Ok(Value::Object(map)),
438            #[cfg(feature = "arbitrary_precision")]
439            SerializeMap::Number { .. } => unreachable!(),
440            #[cfg(feature = "raw_value")]
441            SerializeMap::RawValue { .. } => unreachable!(),
442        }
443    }
444}
445
446struct MapKeySerializer;
447
448fn key_must_be_a_string() -> Error {
449    Error::syntax(ErrorCode::KeyMustBeAString, 0, 0)
450}
451
452fn float_key_must_be_finite() -> Error {
453    Error::syntax(ErrorCode::FloatKeyMustBeFinite, 0, 0)
454}
455
456impl serde::Serializer for MapKeySerializer {
457    type Ok = String;
458    type Error = Error;
459
460    type SerializeSeq = Impossible<String, Error>;
461    type SerializeTuple = Impossible<String, Error>;
462    type SerializeTupleStruct = Impossible<String, Error>;
463    type SerializeTupleVariant = Impossible<String, Error>;
464    type SerializeMap = Impossible<String, Error>;
465    type SerializeStruct = Impossible<String, Error>;
466    type SerializeStructVariant = Impossible<String, Error>;
467
468    #[inline]
469    fn serialize_unit_variant(
470        self,
471        _name: &'static str,
472        _variant_index: u32,
473        variant: &'static str,
474    ) -> Result<String> {
475        Ok(variant.to_owned())
476    }
477
478    #[inline]
479    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<String>
480    where
481        T: ?Sized + Serialize,
482    {
483        value.serialize(self)
484    }
485
486    fn serialize_bool(self, value: bool) -> Result<String> {
487        Ok(value.to_string())
488    }
489
490    fn serialize_i8(self, value: i8) -> Result<String> {
491        Ok(value.to_string())
492    }
493
494    fn serialize_i16(self, value: i16) -> Result<String> {
495        Ok(value.to_string())
496    }
497
498    fn serialize_i32(self, value: i32) -> Result<String> {
499        Ok(value.to_string())
500    }
501
502    fn serialize_i64(self, value: i64) -> Result<String> {
503        Ok(value.to_string())
504    }
505
506    fn serialize_u8(self, value: u8) -> Result<String> {
507        Ok(value.to_string())
508    }
509
510    fn serialize_u16(self, value: u16) -> Result<String> {
511        Ok(value.to_string())
512    }
513
514    fn serialize_u32(self, value: u32) -> Result<String> {
515        Ok(value.to_string())
516    }
517
518    fn serialize_u64(self, value: u64) -> Result<String> {
519        Ok(value.to_string())
520    }
521
522    fn serialize_f32(self, value: f32) -> Result<String> {
523        if value.is_finite() {
524            Ok(ryu::Buffer::new().format_finite(value).to_owned())
525        } else {
526            Err(float_key_must_be_finite())
527        }
528    }
529
530    fn serialize_f64(self, value: f64) -> Result<String> {
531        if value.is_finite() {
532            Ok(ryu::Buffer::new().format_finite(value).to_owned())
533        } else {
534            Err(float_key_must_be_finite())
535        }
536    }
537
538    #[inline]
539    fn serialize_char(self, value: char) -> Result<String> {
540        Ok({
541            let mut s = String::new();
542            s.push(value);
543            s
544        })
545    }
546
547    #[inline]
548    fn serialize_str(self, value: &str) -> Result<String> {
549        Ok(value.to_owned())
550    }
551
552    fn serialize_bytes(self, _value: &[u8]) -> Result<String> {
553        Err(key_must_be_a_string())
554    }
555
556    fn serialize_unit(self) -> Result<String> {
557        Err(key_must_be_a_string())
558    }
559
560    fn serialize_unit_struct(self, _name: &'static str) -> Result<String> {
561        Err(key_must_be_a_string())
562    }
563
564    fn serialize_newtype_variant<T>(
565        self,
566        _name: &'static str,
567        _variant_index: u32,
568        _variant: &'static str,
569        _value: &T,
570    ) -> Result<String>
571    where
572        T: ?Sized + Serialize,
573    {
574        Err(key_must_be_a_string())
575    }
576
577    fn serialize_none(self) -> Result<String> {
578        Err(key_must_be_a_string())
579    }
580
581    fn serialize_some<T>(self, _value: &T) -> Result<String>
582    where
583        T: ?Sized + Serialize,
584    {
585        Err(key_must_be_a_string())
586    }
587
588    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
589        Err(key_must_be_a_string())
590    }
591
592    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
593        Err(key_must_be_a_string())
594    }
595
596    fn serialize_tuple_struct(
597        self,
598        _name: &'static str,
599        _len: usize,
600    ) -> Result<Self::SerializeTupleStruct> {
601        Err(key_must_be_a_string())
602    }
603
604    fn serialize_tuple_variant(
605        self,
606        _name: &'static str,
607        _variant_index: u32,
608        _variant: &'static str,
609        _len: usize,
610    ) -> Result<Self::SerializeTupleVariant> {
611        Err(key_must_be_a_string())
612    }
613
614    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
615        Err(key_must_be_a_string())
616    }
617
618    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
619        Err(key_must_be_a_string())
620    }
621
622    fn serialize_struct_variant(
623        self,
624        _name: &'static str,
625        _variant_index: u32,
626        _variant: &'static str,
627        _len: usize,
628    ) -> Result<Self::SerializeStructVariant> {
629        Err(key_must_be_a_string())
630    }
631
632    fn collect_str<T>(self, value: &T) -> Result<String>
633    where
634        T: ?Sized + Display,
635    {
636        Ok(value.to_string())
637    }
638}
639
640impl serde::ser::SerializeStruct for SerializeMap {
641    type Ok = Value;
642    type Error = Error;
643
644    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
645    where
646        T: ?Sized + Serialize,
647    {
648        match self {
649            SerializeMap::Map { .. } => serde::ser::SerializeMap::serialize_entry(self, key, value),
650            #[cfg(feature = "arbitrary_precision")]
651            SerializeMap::Number { out_value } => {
652                if key == crate::number::TOKEN {
653                    *out_value = Some(tri!(value.serialize(NumberValueEmitter)));
654                    Ok(())
655                } else {
656                    Err(invalid_number())
657                }
658            }
659            #[cfg(feature = "raw_value")]
660            SerializeMap::RawValue { out_value } => {
661                if key == crate::raw::TOKEN {
662                    *out_value = Some(tri!(value.serialize(RawValueEmitter)));
663                    Ok(())
664                } else {
665                    Err(invalid_raw_value())
666                }
667            }
668        }
669    }
670
671    fn end(self) -> Result<Value> {
672        match self {
673            SerializeMap::Map { .. } => serde::ser::SerializeMap::end(self),
674            #[cfg(feature = "arbitrary_precision")]
675            SerializeMap::Number { out_value, .. } => {
676                Ok(out_value.expect("number value was not emitted"))
677            }
678            #[cfg(feature = "raw_value")]
679            SerializeMap::RawValue { out_value, .. } => {
680                Ok(out_value.expect("raw value was not emitted"))
681            }
682        }
683    }
684}
685
686impl serde::ser::SerializeStructVariant for SerializeStructVariant {
687    type Ok = Value;
688    type Error = Error;
689
690    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
691    where
692        T: ?Sized + Serialize,
693    {
694        self.map.insert(String::from(key), tri!(to_value(value)));
695        Ok(())
696    }
697
698    fn end(self) -> Result<Value> {
699        let mut object = Map::new();
700
701        object.insert(self.name, Value::Object(self.map));
702
703        Ok(Value::Object(object))
704    }
705}
706
707#[cfg(feature = "arbitrary_precision")]
708struct NumberValueEmitter;
709
710#[cfg(feature = "arbitrary_precision")]
711fn invalid_number() -> Error {
712    Error::syntax(ErrorCode::InvalidNumber, 0, 0)
713}
714
715#[cfg(feature = "arbitrary_precision")]
716impl serde::ser::Serializer for NumberValueEmitter {
717    type Ok = Value;
718    type Error = Error;
719
720    type SerializeSeq = Impossible<Value, Error>;
721    type SerializeTuple = Impossible<Value, Error>;
722    type SerializeTupleStruct = Impossible<Value, Error>;
723    type SerializeTupleVariant = Impossible<Value, Error>;
724    type SerializeMap = Impossible<Value, Error>;
725    type SerializeStruct = Impossible<Value, Error>;
726    type SerializeStructVariant = Impossible<Value, Error>;
727
728    fn serialize_bool(self, _v: bool) -> Result<Value> {
729        Err(invalid_number())
730    }
731
732    fn serialize_i8(self, _v: i8) -> Result<Value> {
733        Err(invalid_number())
734    }
735
736    fn serialize_i16(self, _v: i16) -> Result<Value> {
737        Err(invalid_number())
738    }
739
740    fn serialize_i32(self, _v: i32) -> Result<Value> {
741        Err(invalid_number())
742    }
743
744    fn serialize_i64(self, _v: i64) -> Result<Value> {
745        Err(invalid_number())
746    }
747
748    fn serialize_u8(self, _v: u8) -> Result<Value> {
749        Err(invalid_number())
750    }
751
752    fn serialize_u16(self, _v: u16) -> Result<Value> {
753        Err(invalid_number())
754    }
755
756    fn serialize_u32(self, _v: u32) -> Result<Value> {
757        Err(invalid_number())
758    }
759
760    fn serialize_u64(self, _v: u64) -> Result<Value> {
761        Err(invalid_number())
762    }
763
764    fn serialize_f32(self, _v: f32) -> Result<Value> {
765        Err(invalid_number())
766    }
767
768    fn serialize_f64(self, _v: f64) -> Result<Value> {
769        Err(invalid_number())
770    }
771
772    fn serialize_char(self, _v: char) -> Result<Value> {
773        Err(invalid_number())
774    }
775
776    fn serialize_str(self, value: &str) -> Result<Value> {
777        let n = tri!(value.to_owned().parse());
778        Ok(Value::Number(n))
779    }
780
781    fn serialize_bytes(self, _value: &[u8]) -> Result<Value> {
782        Err(invalid_number())
783    }
784
785    fn serialize_none(self) -> Result<Value> {
786        Err(invalid_number())
787    }
788
789    fn serialize_some<T>(self, _value: &T) -> Result<Value>
790    where
791        T: ?Sized + Serialize,
792    {
793        Err(invalid_number())
794    }
795
796    fn serialize_unit(self) -> Result<Value> {
797        Err(invalid_number())
798    }
799
800    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
801        Err(invalid_number())
802    }
803
804    fn serialize_unit_variant(
805        self,
806        _name: &'static str,
807        _variant_index: u32,
808        _variant: &'static str,
809    ) -> Result<Value> {
810        Err(invalid_number())
811    }
812
813    fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<Value>
814    where
815        T: ?Sized + Serialize,
816    {
817        Err(invalid_number())
818    }
819
820    fn serialize_newtype_variant<T>(
821        self,
822        _name: &'static str,
823        _variant_index: u32,
824        _variant: &'static str,
825        _value: &T,
826    ) -> Result<Value>
827    where
828        T: ?Sized + Serialize,
829    {
830        Err(invalid_number())
831    }
832
833    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
834        Err(invalid_number())
835    }
836
837    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
838        Err(invalid_number())
839    }
840
841    fn serialize_tuple_struct(
842        self,
843        _name: &'static str,
844        _len: usize,
845    ) -> Result<Self::SerializeTupleStruct> {
846        Err(invalid_number())
847    }
848
849    fn serialize_tuple_variant(
850        self,
851        _name: &'static str,
852        _variant_index: u32,
853        _variant: &'static str,
854        _len: usize,
855    ) -> Result<Self::SerializeTupleVariant> {
856        Err(invalid_number())
857    }
858
859    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
860        Err(invalid_number())
861    }
862
863    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
864        Err(invalid_number())
865    }
866
867    fn serialize_struct_variant(
868        self,
869        _name: &'static str,
870        _variant_index: u32,
871        _variant: &'static str,
872        _len: usize,
873    ) -> Result<Self::SerializeStructVariant> {
874        Err(invalid_number())
875    }
876}
877
878#[cfg(feature = "raw_value")]
879struct RawValueEmitter;
880
881#[cfg(feature = "raw_value")]
882fn invalid_raw_value() -> Error {
883    Error::syntax(ErrorCode::ExpectedSomeValue, 0, 0)
884}
885
886#[cfg(feature = "raw_value")]
887impl serde::ser::Serializer for RawValueEmitter {
888    type Ok = Value;
889    type Error = Error;
890
891    type SerializeSeq = Impossible<Value, Error>;
892    type SerializeTuple = Impossible<Value, Error>;
893    type SerializeTupleStruct = Impossible<Value, Error>;
894    type SerializeTupleVariant = Impossible<Value, Error>;
895    type SerializeMap = Impossible<Value, Error>;
896    type SerializeStruct = Impossible<Value, Error>;
897    type SerializeStructVariant = Impossible<Value, Error>;
898
899    fn serialize_bool(self, _v: bool) -> Result<Value> {
900        Err(invalid_raw_value())
901    }
902
903    fn serialize_i8(self, _v: i8) -> Result<Value> {
904        Err(invalid_raw_value())
905    }
906
907    fn serialize_i16(self, _v: i16) -> Result<Value> {
908        Err(invalid_raw_value())
909    }
910
911    fn serialize_i32(self, _v: i32) -> Result<Value> {
912        Err(invalid_raw_value())
913    }
914
915    fn serialize_i64(self, _v: i64) -> Result<Value> {
916        Err(invalid_raw_value())
917    }
918
919    fn serialize_u8(self, _v: u8) -> Result<Value> {
920        Err(invalid_raw_value())
921    }
922
923    fn serialize_u16(self, _v: u16) -> Result<Value> {
924        Err(invalid_raw_value())
925    }
926
927    fn serialize_u32(self, _v: u32) -> Result<Value> {
928        Err(invalid_raw_value())
929    }
930
931    fn serialize_u64(self, _v: u64) -> Result<Value> {
932        Err(invalid_raw_value())
933    }
934
935    fn serialize_f32(self, _v: f32) -> Result<Value> {
936        Err(invalid_raw_value())
937    }
938
939    fn serialize_f64(self, _v: f64) -> Result<Value> {
940        Err(invalid_raw_value())
941    }
942
943    fn serialize_char(self, _v: char) -> Result<Value> {
944        Err(invalid_raw_value())
945    }
946
947    fn serialize_str(self, value: &str) -> Result<Value> {
948        crate::from_str(value)
949    }
950
951    fn serialize_bytes(self, _value: &[u8]) -> Result<Value> {
952        Err(invalid_raw_value())
953    }
954
955    fn serialize_none(self) -> Result<Value> {
956        Err(invalid_raw_value())
957    }
958
959    fn serialize_some<T>(self, _value: &T) -> Result<Value>
960    where
961        T: ?Sized + Serialize,
962    {
963        Err(invalid_raw_value())
964    }
965
966    fn serialize_unit(self) -> Result<Value> {
967        Err(invalid_raw_value())
968    }
969
970    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
971        Err(invalid_raw_value())
972    }
973
974    fn serialize_unit_variant(
975        self,
976        _name: &'static str,
977        _variant_index: u32,
978        _variant: &'static str,
979    ) -> Result<Value> {
980        Err(invalid_raw_value())
981    }
982
983    fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<Value>
984    where
985        T: ?Sized + Serialize,
986    {
987        Err(invalid_raw_value())
988    }
989
990    fn serialize_newtype_variant<T>(
991        self,
992        _name: &'static str,
993        _variant_index: u32,
994        _variant: &'static str,
995        _value: &T,
996    ) -> Result<Value>
997    where
998        T: ?Sized + Serialize,
999    {
1000        Err(invalid_raw_value())
1001    }
1002
1003    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
1004        Err(invalid_raw_value())
1005    }
1006
1007    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
1008        Err(invalid_raw_value())
1009    }
1010
1011    fn serialize_tuple_struct(
1012        self,
1013        _name: &'static str,
1014        _len: usize,
1015    ) -> Result<Self::SerializeTupleStruct> {
1016        Err(invalid_raw_value())
1017    }
1018
1019    fn serialize_tuple_variant(
1020        self,
1021        _name: &'static str,
1022        _variant_index: u32,
1023        _variant: &'static str,
1024        _len: usize,
1025    ) -> Result<Self::SerializeTupleVariant> {
1026        Err(invalid_raw_value())
1027    }
1028
1029    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
1030        Err(invalid_raw_value())
1031    }
1032
1033    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
1034        Err(invalid_raw_value())
1035    }
1036
1037    fn serialize_struct_variant(
1038        self,
1039        _name: &'static str,
1040        _variant_index: u32,
1041        _variant: &'static str,
1042        _len: usize,
1043    ) -> Result<Self::SerializeStructVariant> {
1044        Err(invalid_raw_value())
1045    }
1046
1047    fn collect_str<T>(self, value: &T) -> Result<Self::Ok>
1048    where
1049        T: ?Sized + Display,
1050    {
1051        self.serialize_str(&value.to_string())
1052    }
1053}
serde_json/value/ser.rs

serde_json/value/
ser.rs
