1use std::io;
2
3use serde::ser::Impossible;
4use serde::Serialize;
5
6use crate::error::{self, Result};
7use crate::{error::Error, CompactFormatter, Formatter, PrettyFormatter};
8use crate::{format_escaped_str, format_key};
9
10#[allow(dead_code)]
11pub struct Serializer<W, F = CompactFormatter> {
12 pub(crate) writer: W,
13 pub(crate) formatter: F,
14}
15
16impl<'a, W> Serializer<W, PrettyFormatter<'a>>
17where
18 W: io::Write,
19{
20 pub fn pretty(writer: W) -> Self {
21 Serializer::with_formatter(writer, PrettyFormatter::new())
22 }
23}
24
25impl<W, F> Serializer<W, F>
26where
27 W: io::Write,
28 F: Formatter,
29{
30 pub fn with_formatter(writer: W, formatter: F) -> Self {
31 Serializer { writer, formatter }
32 }
33}
34
35#[allow(dead_code, unused_variables)]
36impl<'a, W, F> serde::ser::Serializer for &'a mut Serializer<W, F>
37where
38 W: io::Write,
39 F: Formatter,
40{
41 type Ok = ();
42 type Error = Error;
43
44 type SerializeSeq = Compount<'a, W, F>;
45 type SerializeTuple = Compount<'a, W, F>;
46 type SerializeTupleStruct = Compount<'a, W, F>;
47 type SerializeTupleVariant = Compount<'a, W, F>;
48 type SerializeMap = Compount<'a, W, F>;
49 type SerializeStruct = Compount<'a, W, F>;
50 type SerializeStructVariant = Compount<'a, W, F>;
51
52 fn serialize_bool(self, v: bool) -> Result<()> {
53 self.formatter
54 .write_bool(&mut self.writer, v)
55 .map_err(Error::io)
56 }
57
58 fn serialize_i8(self, v: i8) -> Result<()> {
59 self.formatter
60 .write_i8(&mut self.writer, v)
61 .map_err(Error::io)
62 }
63
64 fn serialize_i16(self, v: i16) -> Result<()> {
65 self.formatter
66 .write_i16(&mut self.writer, v)
67 .map_err(Error::io)
68 }
69
70 fn serialize_i32(self, v: i32) -> Result<()> {
71 self.formatter
72 .write_i32(&mut self.writer, v)
73 .map_err(Error::io)
74 }
75
76 fn serialize_i64(self, v: i64) -> Result<()> {
77 self.formatter
78 .write_i64(&mut self.writer, v)
79 .map_err(Error::io)
80 }
81
82 fn serialize_u8(self, v: u8) -> Result<()> {
83 self.formatter
84 .write_u8(&mut self.writer, v)
85 .map_err(Error::io)
86 }
87
88 fn serialize_u16(self, v: u16) -> Result<()> {
89 self.formatter
90 .write_u16(&mut self.writer, v)
91 .map_err(Error::io)
92 }
93
94 fn serialize_u32(self, v: u32) -> Result<()> {
95 self.formatter
96 .write_u32(&mut self.writer, v)
97 .map_err(Error::io)
98 }
99
100 fn serialize_u64(self, v: u64) -> Result<()> {
101 self.formatter
102 .write_u64(&mut self.writer, v)
103 .map_err(Error::io)
104 }
105
106 fn serialize_f32(self, v: f32) -> Result<()> {
107 self.formatter
108 .write_f32(&mut self.writer, v)
109 .map_err(Error::io)
110 }
111
112 fn serialize_f64(self, v: f64) -> Result<()> {
113 self.formatter
114 .write_f64(&mut self.writer, v)
115 .map_err(Error::io)
116 }
117
118 fn serialize_char(self, v: char) -> Result<()> {
119 self.formatter
120 .write_char(&mut self.writer, v)
121 .map_err(Error::io)
122 }
123
124 fn serialize_str(self, v: &str) -> Result<()> {
125 format_escaped_str(&mut self.writer, &mut self.formatter, v).map_err(Error::io)
126 }
127
128 fn serialize_bytes(self, v: &[u8]) -> Result<()> {
129 todo!()
130 }
131
132 fn serialize_none(self) -> Result<()> {
133 self.serialize_unit()
134 }
135
136 fn serialize_some<T>(self, value: &T) -> Result<()>
137 where
138 T: Serialize,
139 T: ?Sized,
140 {
141 value.serialize(self)
142 }
143
144 fn serialize_unit(self) -> Result<()> {
145 self.formatter
146 .write_null(&mut self.writer)
147 .map_err(Error::io)
148 }
149
150 fn serialize_unit_struct(self, name: &'static str) -> Result<()> {
151 self.formatter
152 .write_null(&mut self.writer)
153 .map_err(Error::io)
154 }
155
156 fn serialize_unit_variant(
157 self,
158 name: &'static str,
159 variant_index: u32,
160 variant: &'static str,
161 ) -> Result<()> {
162 self.formatter
163 .write_string(&mut self.writer, variant)
164 .map_err(Error::io)
165 }
166
167 fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<()>
168 where
169 T: Serialize,
170 T: ?Sized,
171 {
172 value.serialize(self)
173 }
174
175 fn serialize_newtype_variant<T>(
176 self,
177 name: &'static str,
178 variant_index: u32,
179 variant: &'static str,
180 value: &T,
181 ) -> Result<()>
182 where
183 T: Serialize,
184 T: ?Sized,
185 {
186 self.formatter
187 .begin_object(&mut self.writer)
188 .map_err(Error::io)?;
189 self.formatter
190 .begin_object_key(&mut self.writer, true)
191 .map_err(Error::io)?;
192 self.serialize_str(variant)?;
193 self.formatter
194 .end_object_key(&mut self.writer)
195 .map_err(Error::io)?;
196 self.formatter
197 .begin_object_value(&mut self.writer)
198 .map_err(Error::io)?;
199 value.serialize(&mut *self)?;
200 self.formatter
201 .end_object_value(&mut self.writer)
202 .map_err(Error::io)?;
203 self.formatter
204 .end_object(&mut self.writer)
205 .map_err(Error::io)
206 }
207
208 fn serialize_seq(
209 self,
210 len: Option<usize>,
211 ) -> std::prelude::v1::Result<Self::SerializeSeq, Self::Error> {
212 self.formatter
213 .begin_array(&mut self.writer)
214 .map_err(Error::io)?;
215
216 if len == Some(0) {
217 self.formatter
218 .end_array(&mut self.writer)
219 .map_err(Error::io)?;
220
221 Ok(Compount::Map {
222 ser: self,
223 state: State::Empty,
224 })
225 } else {
226 Ok(Compount::Map {
227 ser: self,
228 state: State::First,
229 })
230 }
231 }
232
233 fn serialize_tuple(
234 self,
235 len: usize,
236 ) -> std::prelude::v1::Result<Self::SerializeTuple, Self::Error> {
237 self.serialize_seq(Some(len))
238 }
239
240 fn serialize_tuple_struct(
241 self,
242 name: &'static str,
243 len: usize,
244 ) -> std::prelude::v1::Result<Self::SerializeTupleStruct, Self::Error> {
245 self.serialize_seq(Some(len))
246 }
247
248 fn serialize_tuple_variant(
249 self,
250 name: &'static str,
251 variant_index: u32,
252 variant: &'static str,
253 len: usize,
254 ) -> std::prelude::v1::Result<Self::SerializeTupleVariant, Self::Error> {
255 self.formatter
256 .begin_object(&mut self.writer)
257 .map_err(Error::io)?;
258 self.formatter
259 .begin_object_key(&mut self.writer, true)
260 .map_err(Error::io)?;
261 self.serialize_str(variant)?;
262 self.formatter
263 .end_object_key(&mut self.writer)
264 .map_err(Error::io)?;
265 self.formatter
266 .begin_object_value(&mut self.writer)
267 .map_err(Error::io)?;
268 self.serialize_seq(Some(len))
269 }
270
271 fn serialize_map(
272 self,
273 len: Option<usize>,
274 ) -> std::prelude::v1::Result<Self::SerializeMap, Self::Error> {
275 self.formatter
276 .begin_object(&mut self.writer)
277 .map_err(Error::io)?;
278 if len == Some(0) {
279 self.formatter
280 .end_object(&mut self.writer)
281 .map_err(Error::io)?;
282 Ok(Compount::Map {
283 ser: self,
284 state: State::Empty,
285 })
286 } else {
287 Ok(Compount::Map {
288 ser: self,
289 state: State::First,
290 })
291 }
292 }
293
294 fn serialize_struct(
295 self,
296 name: &'static str,
297 len: usize,
298 ) -> std::prelude::v1::Result<Self::SerializeStruct, Self::Error> {
299 self.serialize_map(Some(len))
300 }
301
302 fn serialize_struct_variant(
303 self,
304 name: &'static str,
305 variant_index: u32,
306 variant: &'static str,
307 len: usize,
308 ) -> std::prelude::v1::Result<Self::SerializeStructVariant, Self::Error> {
309 self.formatter
310 .begin_object(&mut self.writer)
311 .map_err(Error::io)?;
312 self.formatter
313 .begin_object_key(&mut self.writer, true)
314 .map_err(Error::io)?;
315 self.serialize_str(variant)?;
316 self.formatter
317 .end_object_key(&mut self.writer)
318 .map_err(Error::io)?;
319 self.formatter
320 .begin_object_value(&mut self.writer)
321 .map_err(Error::io)?;
322 self.serialize_map(Some(len))
323 }
324}
325
326struct MapKeySerializer<'a, W: 'a, F: 'a> {
327 ser: &'a mut Serializer<W, F>,
328}
329
330impl<'a, W, F> serde::ser::Serializer for MapKeySerializer<'a, W, F>
331where
332 W: io::Write,
333 F: Formatter,
334{
335 type Ok = ();
336 type Error = Error;
337
338 type SerializeSeq = Impossible<(), Error>;
339 type SerializeTuple = Impossible<(), Error>;
340 type SerializeTupleStruct = Impossible<(), Error>;
341 type SerializeTupleVariant = Impossible<(), Error>;
342 type SerializeMap = Impossible<(), Error>;
343 type SerializeStruct = Impossible<(), Error>;
344 type SerializeStructVariant = Impossible<(), Error>;
345
346 fn serialize_bool(self, _v: bool) -> Result<()> {
347 todo!()
348 }
349
350 fn serialize_i8(self, _v: i8) -> Result<()> {
351 todo!()
352 }
353
354 fn serialize_i16(self, _v: i16) -> Result<()> {
355 todo!()
356 }
357
358 fn serialize_i32(self, _v: i32) -> Result<()> {
359 todo!()
360 }
361
362 fn serialize_i64(self, _v: i64) -> Result<()> {
363 todo!()
364 }
365
366 fn serialize_u8(self, _v: u8) -> Result<()> {
367 todo!()
368 }
369
370 fn serialize_u16(self, _v: u16) -> Result<()> {
371 todo!()
372 }
373
374 fn serialize_u32(self, _v: u32) -> Result<()> {
375 todo!()
376 }
377
378 fn serialize_u64(self, _v: u64) -> Result<()> {
379 todo!()
380 }
381
382 fn serialize_f32(self, _v: f32) -> Result<()> {
383 todo!()
384 }
385
386 fn serialize_f64(self, _v: f64) -> Result<()> {
387 todo!()
388 }
389
390 fn serialize_char(self, _v: char) -> Result<()> {
391 todo!()
392 }
393
394 fn serialize_str(self, v: &str) -> Result<()> {
395 format_key(&mut self.ser.writer, &mut self.ser.formatter, v).map_err(Error::io)
396 }
397
398 fn serialize_bytes(self, _v: &[u8]) -> Result<()> {
399 todo!()
400 }
401
402 fn serialize_none(self) -> Result<()> {
403 todo!()
404 }
405
406 fn serialize_some<T>(self, _value: &T) -> Result<()>
407 where
408 T: Serialize,
409 T: ?Sized,
410 {
411 todo!()
412 }
413
414 fn serialize_unit(self) -> Result<()> {
415 todo!()
416 }
417
418 fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
419 todo!()
420 }
421
422 fn serialize_unit_variant(
423 self,
424 _name: &'static str,
425 _variant_index: u32,
426 _variant: &'static str,
427 ) -> Result<()> {
428 todo!()
429 }
430
431 fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<()>
432 where
433 T: Serialize,
434 T: ?Sized,
435 {
436 todo!()
437 }
438
439 fn serialize_newtype_variant<T>(
440 self,
441 _name: &'static str,
442 _variant_index: u32,
443 _variant: &'static str,
444 _value: &T,
445 ) -> Result<()>
446 where
447 T: Serialize,
448 T: ?Sized,
449 {
450 todo!()
451 }
452
453 fn serialize_seq(
454 self,
455 _len: Option<usize>,
456 ) -> std::prelude::v1::Result<Self::SerializeSeq, Self::Error> {
457 todo!()
458 }
459
460 fn serialize_tuple(
461 self,
462 _len: usize,
463 ) -> std::prelude::v1::Result<Self::SerializeTuple, Self::Error> {
464 todo!()
465 }
466
467 fn serialize_tuple_struct(
468 self,
469 _name: &'static str,
470 _len: usize,
471 ) -> std::prelude::v1::Result<Self::SerializeTupleStruct, Self::Error> {
472 todo!()
473 }
474
475 fn serialize_tuple_variant(
476 self,
477 _name: &'static str,
478 _variant_index: u32,
479 _variant: &'static str,
480 _len: usize,
481 ) -> std::prelude::v1::Result<Self::SerializeTupleVariant, Self::Error> {
482 todo!()
483 }
484
485 fn serialize_map(
486 self,
487 _len: Option<usize>,
488 ) -> std::prelude::v1::Result<Self::SerializeMap, Self::Error> {
489 todo!()
490 }
491
492 fn serialize_struct(
493 self,
494 _name: &'static str,
495 _len: usize,
496 ) -> std::prelude::v1::Result<Self::SerializeStruct, Self::Error> {
497 todo!()
498 }
499
500 fn serialize_struct_variant(
501 self,
502 _name: &'static str,
503 _variant_index: u32,
504 _variant: &'static str,
505 _len: usize,
506 ) -> std::prelude::v1::Result<Self::SerializeStructVariant, Self::Error> {
507 todo!()
508 }
509}
510
511#[derive(Eq, PartialEq)]
512pub enum State {
513 Empty,
514 First,
515 Rest,
516}
517
518pub enum Compount<'a, W: 'a, F: 'a> {
519 Map {
520 ser: &'a mut Serializer<W, F>,
521 state: State,
522 },
523}
524
525impl<'a, W, F> serde::ser::SerializeSeq for Compount<'a, W, F>
526where
527 W: io::Write,
528 F: Formatter,
529{
530 type Ok = ();
531 type Error = error::Error;
532
533 fn serialize_element<T>(&mut self, value: &T) -> std::prelude::v1::Result<(), Self::Error>
534 where
535 T: Serialize,
536 T: ?Sized,
537 {
538 match self {
539 Compount::Map { ser, state } => {
540 ser.formatter
541 .begin_array_value(&mut ser.writer, *state == State::First)
542 .map_err(Error::io)?;
543
544 *state = State::Rest;
545
546 value.serialize(&mut **ser)?;
547
548 ser.formatter
549 .end_array_value(&mut ser.writer)
550 .map_err(Error::io)
551 }
552 }
553 }
554
555 fn end(self) -> Result<()> {
556 match self {
557 Compount::Map { ser, state } => match state {
558 State::Empty => Ok(()),
559 _ => ser.formatter.end_array(&mut ser.writer).map_err(Error::io),
560 },
561 }
562 }
563}
564
565impl<'a, W, F> serde::ser::SerializeTuple for Compount<'a, W, F>
566where
567 W: io::Write,
568 F: Formatter,
569{
570 type Ok = ();
571
572 type Error = error::Error;
573
574 fn serialize_element<T>(&mut self, value: &T) -> std::prelude::v1::Result<(), Self::Error>
575 where
576 T: Serialize,
577 T: ?Sized,
578 {
579 serde::ser::SerializeSeq::serialize_element(self, value)
580 }
581
582 fn end(self) -> Result<()> {
583 serde::ser::SerializeSeq::end(self)
584 }
585}
586impl<'a, W, F> serde::ser::SerializeTupleStruct for Compount<'a, W, F>
587where
588 W: io::Write,
589 F: Formatter,
590{
591 type Ok = ();
592
593 type Error = error::Error;
594
595 fn serialize_field<T>(&mut self, value: &T) -> std::prelude::v1::Result<(), Self::Error>
596 where
597 T: Serialize,
598 T: ?Sized,
599 {
600 serde::ser::SerializeSeq::serialize_element(self, value)
601 }
602
603 fn end(self) -> Result<()> {
604 serde::ser::SerializeSeq::end(self)
605 }
606}
607impl<'a, W, F> serde::ser::SerializeTupleVariant for Compount<'a, W, F>
608where
609 W: io::Write,
610 F: Formatter,
611{
612 type Ok = ();
613
614 type Error = error::Error;
615
616 fn serialize_field<T>(&mut self, value: &T) -> std::prelude::v1::Result<(), Self::Error>
617 where
618 T: Serialize,
619 T: ?Sized,
620 {
621 serde::ser::SerializeSeq::serialize_element(self, value)
622 }
623
624 fn end(self) -> Result<()> {
625 match self {
626 Compount::Map { ser, state } => {
627 match state {
628 State::Empty => {}
629 _ => ser
630 .formatter
631 .end_array(&mut ser.writer)
632 .map_err(Error::io)?,
633 }
634
635 ser.formatter
636 .end_object_value(&mut ser.writer)
637 .map_err(Error::io)?;
638 ser.formatter.end_object(&mut ser.writer).map_err(Error::io)
639 }
640 }
641 }
642}
643
644impl<'a, W, F> serde::ser::SerializeMap for Compount<'a, W, F>
645where
646 W: io::Write,
647 F: Formatter,
648{
649 type Ok = ();
650
651 type Error = error::Error;
652
653 fn serialize_key<T>(&mut self, key: &T) -> std::prelude::v1::Result<(), Self::Error>
654 where
655 T: Serialize,
656 T: ?Sized,
657 {
658 match self {
659 Compount::Map { ser, state } => {
660 ser.formatter
661 .begin_object_key(&mut ser.writer, *state == State::First)
662 .map_err(Error::io)?;
663 *state = State::Rest;
664
665 key.serialize(MapKeySerializer { ser: *ser })?;
666 ser.formatter
667 .end_object_key(&mut ser.writer)
668 .map_err(Error::io)
669 }
670 }
671 }
672
673 fn serialize_value<T>(&mut self, value: &T) -> std::prelude::v1::Result<(), Self::Error>
674 where
675 T: Serialize,
676 T: ?Sized,
677 {
678 match self {
679 Compount::Map { ser, .. } => {
680 ser.formatter
681 .begin_object_value(&mut ser.writer)
682 .map_err(Error::io)?;
683 value.serialize(&mut **ser)?;
684 ser.formatter
685 .end_object_value(&mut ser.writer)
686 .map_err(Error::io)
687 }
688 }
689 }
690
691 fn end(self) -> Result<()> {
692 match self {
693 Compount::Map { ser, state } => match state {
694 State::Empty => Ok(()),
695 _ => ser.formatter.end_object(&mut ser.writer).map_err(Error::io),
696 },
697 }
698 }
699}
700
701impl<'a, W, F> serde::ser::SerializeStruct for Compount<'a, W, F>
702where
703 W: io::Write,
704 F: Formatter,
705{
706 type Ok = ();
707
708 type Error = error::Error;
709
710 fn serialize_field<T>(
711 &mut self,
712 key: &'static str,
713 value: &T,
714 ) -> std::prelude::v1::Result<(), Self::Error>
715 where
716 T: Serialize,
717 T: ?Sized,
718 {
719 match self {
720 Compount::Map { .. } => serde::ser::SerializeMap::serialize_entry(self, key, value),
721 }
722 }
723
724 fn end(self) -> Result<()> {
725 match self {
726 Compount::Map { .. } => serde::ser::SerializeMap::end(self),
727 }
728 }
729}
730
731impl<'a, W, F> serde::ser::SerializeStructVariant for Compount<'a, W, F>
732where
733 W: io::Write,
734 F: Formatter,
735{
736 type Ok = ();
737
738 type Error = error::Error;
739
740 fn serialize_field<T>(
741 &mut self,
742 key: &'static str,
743 value: &T,
744 ) -> std::prelude::v1::Result<(), Self::Error>
745 where
746 T: Serialize,
747 T: ?Sized,
748 {
749 match self {
750 Compount::Map { .. } => serde::ser::SerializeStruct::serialize_field(self, key, value),
751 }
752 }
753
754 fn end(self) -> Result<()> {
755 match self {
756 Compount::Map { ser, state } => {
757 match state {
758 State::Empty => {}
759 _ => ser
760 .formatter
761 .end_object(&mut ser.writer)
762 .map_err(Error::io)?,
763 }
764 ser.formatter
765 .end_object_value(&mut ser.writer)
766 .map_err(Error::io)?;
767 ser.formatter.end_object(&mut ser.writer).map_err(Error::io)
768 }
769 }
770 }
771}