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 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}