forte_json/
lib.rs

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

forte_json/
lib.rs
