serde_json/value/
ser.rs

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