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

serde_json/value/
ser.rs
