rs_flow/package/serde/
serializer.rs

1use std::{collections::HashMap, fmt::Display};
2
3use thiserror::Error;
4use serde::{
5    ser::{
6        SerializeMap, 
7        SerializeSeq, 
8        SerializeStruct, 
9        SerializeStructVariant, 
10        SerializeTuple, 
11        SerializeTupleStruct, 
12        SerializeTupleVariant
13    }, Serialize, Serializer
14};
15
16use crate::package::Package;
17
18#[derive(Debug, Error)]
19#[error("Serialize into a package fail, cause: {cause:?}")]
20pub struct PackageSerializerError {
21    pub cause: String
22}
23
24impl serde::ser::Error for PackageSerializerError {
25    fn custom<T>(msg:T) -> Self 
26        where T: Display 
27    {
28        PackageSerializerError { cause: msg.to_string() }
29    }
30}
31
32pub fn serialize<T: Serialize>(value: T) -> 
33    Result<Package, PackageSerializerError> 
34{
35    value.serialize(PackageSerializer)
36}
37
38// region: MapKeySerializer
39struct MapKeySerializer;
40struct Impossible; 
41
42impl Serializer for MapKeySerializer {
43    type Ok = String;
44    type Error = PackageSerializerError;
45
46    type SerializeSeq = Impossible;
47    type SerializeTuple = Impossible;
48    type SerializeTupleStruct = Impossible;
49    type SerializeTupleVariant = Impossible;
50    type SerializeMap = Impossible;
51    type SerializeStruct = Impossible;
52    type SerializeStructVariant = Impossible;
53
54    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
55        Ok(v.to_string())
56    }
57
58    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
59        Ok(v.to_string())
60    }
61    
62    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
63        Ok(v.to_string())
64    }
65
66    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
67        Ok(v.to_string())
68    }
69
70    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
71        Ok(v.to_string())
72    }
73
74    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
75        Ok(v.to_string())
76    }
77
78    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
79        Ok(v.to_string())
80    }
81
82    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
83        Ok(v.to_string())
84    }
85
86    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
87        Ok(v.to_string())
88    }
89
90    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
91        Ok(v.to_string())
92    }
93
94    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
95        Ok(v.to_string())
96    }
97
98    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
99        Ok(v.to_string())
100    }
101
102    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
103        Ok(v.to_string())
104    }
105
106    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
107        Err(PackageSerializerError { cause: "Only string can be a key".to_owned() })
108    }
109
110    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
111        Ok("".to_string())
112    }
113
114    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
115    where
116        T: serde::Serialize {
117        value.serialize(self)
118    }
119
120    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
121        Ok("".to_string())
122    }
123
124    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
125        Ok(name.to_string())
126    }
127
128    fn serialize_unit_variant(
129        self,
130        _name: &'static str,
131        _variant_index: u32,
132        variant: &'static str,
133    ) -> Result<Self::Ok, Self::Error> {
134        Ok(variant.to_string())
135    }
136
137    fn serialize_newtype_struct<T: ?Sized>(
138        self,
139        _name: &'static str,
140        _value: &T,
141    ) -> Result<Self::Ok, Self::Error>
142    where
143        T: serde::Serialize {
144        Err(PackageSerializerError { cause: "Variant cannot be serialized into string".to_owned() })
145    }
146
147    fn serialize_newtype_variant<T: ?Sized>(
148        self,
149        _name: &'static str,
150        _variant_index: u32,
151        _variant: &'static str,
152        _value: &T,
153    ) -> Result<Self::Ok, Self::Error>
154    where
155        T: serde::Serialize {
156        Err(PackageSerializerError { cause: "Variant cannot be serialized into string".to_owned() })
157    }
158
159    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
160        Err(PackageSerializerError { cause: "Only string can be a key".to_owned() })
161    }
162
163    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
164        Err(PackageSerializerError { cause: "Only string can be a key".to_owned() })
165    }
166
167    fn serialize_tuple_struct(
168        self,
169        _name: &'static str,
170        _len: usize,
171    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
172        Err(PackageSerializerError { cause: "Only string can be a key".to_owned() })
173    }
174
175    fn serialize_tuple_variant(
176        self,
177        _name: &'static str,
178        _variant_index: u32,
179        _variant: &'static str,
180        _len: usize,
181    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
182        Err(PackageSerializerError { cause: "Only string can be a key".to_owned() })
183    }
184
185    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
186        Err(PackageSerializerError { cause: "Only string can be a key".to_owned() })
187    }
188
189    fn serialize_struct(
190        self,
191        _name: &'static str,
192        _len: usize,
193    ) -> Result<Self::SerializeStruct, Self::Error> {
194        Err(PackageSerializerError { cause: "Only string can be a key".to_owned() })
195    }
196
197    fn serialize_struct_variant(
198        self,
199        _name: &'static str,
200        _variant_index: u32,
201        _variant: &'static str,
202        _len: usize,
203    ) -> Result<Self::SerializeStructVariant, Self::Error> {
204        Err(PackageSerializerError { cause: "Only string can be a key".to_owned() })
205    }
206} 
207
208impl SerializeSeq for Impossible {
209    type Ok = String;
210    type Error = PackageSerializerError;
211
212    fn serialize_element<T: ?Sized>(&mut self, _value: &T) -> Result<(), Self::Error>
213    where
214        T: serde::Serialize {
215        unreachable!()
216    }
217    fn end(self) -> Result<Self::Ok, Self::Error> {
218        unreachable!()
219    }
220}
221
222impl SerializeTuple for Impossible {
223    type Ok = String;
224    type Error = PackageSerializerError;
225
226    fn serialize_element<T: ?Sized>(&mut self, _value: &T) -> Result<(), Self::Error>
227    where
228        T: serde::Serialize {
229        unreachable!()
230    }
231
232    fn end(self) -> Result<Self::Ok, Self::Error> {
233        unreachable!()
234    }
235}
236
237impl SerializeTupleStruct for Impossible {
238    type Ok = String;
239    type Error = PackageSerializerError;
240
241    fn serialize_field<T: ?Sized>(&mut self, _value: &T) -> Result<(), Self::Error>
242    where
243        T: serde::Serialize {
244        unreachable!()
245    }
246
247    fn end(self) -> Result<Self::Ok, Self::Error> {
248        unreachable!()
249    }
250}
251
252impl SerializeTupleVariant for Impossible {
253    type Ok = String;
254    type Error = PackageSerializerError;
255
256    fn serialize_field<T: ?Sized>(&mut self, _value: &T) -> Result<(), Self::Error>
257    where
258        T: serde::Serialize {
259        unreachable!()
260    }
261
262    fn end(self) -> Result<Self::Ok, Self::Error> {
263        unreachable!()
264    }
265}
266
267impl SerializeMap for Impossible {
268    type Ok = String;
269    type Error = PackageSerializerError;
270
271    fn serialize_key<T: ?Sized>(&mut self, _key: &T) -> Result<(), Self::Error>
272    where
273        T: serde::Serialize {
274        unreachable!()
275    }
276
277    fn serialize_value<T: ?Sized>(&mut self, _value: &T) -> Result<(), Self::Error>
278    where
279        T: serde::Serialize {
280        unreachable!()
281    }
282
283    fn end(self) -> Result<Self::Ok, Self::Error> {
284        unreachable!()
285    }
286}
287
288impl SerializeStruct for Impossible {
289    type Ok = String;
290    type Error = PackageSerializerError;
291
292    fn serialize_field<T: ?Sized>(
293        &mut self,
294        _key: &'static str,
295        _value: &T,
296    ) -> Result<(), Self::Error>
297    where
298        T: serde::Serialize {
299        unreachable!()
300    }
301
302    fn end(self) -> Result<Self::Ok, Self::Error> {
303        unreachable!()
304    }
305}
306
307impl SerializeStructVariant for Impossible {
308    type Ok = String;
309    type Error = PackageSerializerError;
310
311    fn serialize_field<T: ?Sized>(
312        &mut self,
313        _key: &'static str,
314        _value: &T,
315    ) -> Result<(), Self::Error>
316    where
317        T: serde::Serialize {
318        unreachable!()
319    }
320    fn end(self) -> Result<Self::Ok, Self::Error> {
321        unreachable!()
322    }
323}
324
325
326// endregion
327
328// region: PackageSerializer
329struct PackageSerializer;
330
331struct CompoundArray {
332    name: Option<String>,
333    data: Vec<Package>
334}
335struct CompoundObjects {
336    name: Option<String>,
337    data: HashMap::<String, Package>,
338}
339
340
341impl Serializer for PackageSerializer {
342    type Ok = Package;
343    type Error = PackageSerializerError;
344
345    type SerializeSeq = CompoundArray;
346    type SerializeTuple = CompoundArray;
347    type SerializeTupleStruct = CompoundArray;
348    type SerializeTupleVariant = CompoundArray;
349    type SerializeMap = CompoundObjects;
350    type SerializeStruct = CompoundObjects;
351    type SerializeStructVariant = CompoundObjects;
352
353    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
354        Ok(v.into())
355    }
356
357    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
358        Ok(v.into())
359    }
360
361    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
362        Ok(v.into())
363    }
364
365    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
366        Ok(v.into())
367    }
368
369    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
370        Ok(v.into())
371    }
372
373    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
374        Ok(v.into())
375    }
376
377    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
378        Ok(v.into())
379    }
380
381    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
382        Ok(v.into())
383    }
384
385    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
386        Ok(v.into())
387    }
388
389    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
390        Ok(v.into())
391    }
392
393    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
394        Ok(v.into())
395    }
396
397    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
398        Ok(Package::String(v.to_string()))
399    }
400
401    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
402        Ok(v.into())
403    }
404
405    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
406        Ok(v.into())
407    }
408
409    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
410        Ok(Package::Empty)
411    }
412
413    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
414    where
415        T: serde::Serialize {
416        value.serialize(self)
417    }
418
419    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
420        Ok(Package::Empty)
421    }
422
423    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
424        Ok(Package::String(name.to_string()))
425    }
426
427    fn serialize_unit_variant(
428        self,
429        _name: &'static str,
430        _variant_index: u32,
431        _variant: &'static str,
432    ) -> Result<Self::Ok, Self::Error> {
433        Ok(Package::Empty)
434    }
435
436    fn serialize_newtype_struct<T: ?Sized>(
437        self,
438        name: &'static str,
439        value: &T,
440    ) -> Result<Self::Ok, Self::Error>
441    where
442        T: serde::Serialize {
443        let value = value.serialize(self)?;
444        let key = name.to_string();
445        Ok(Package::Object(HashMap::from([(key, value)])))
446    }
447
448    fn serialize_newtype_variant<T: ?Sized>(
449        self,
450        _name: &'static str,
451        _variant_index: u32,
452        variant: &'static str,
453        value: &T,
454    ) -> Result<Self::Ok, Self::Error>
455    where
456        T: serde::Serialize {
457        let value = value.serialize(self)?;
458        let key = variant.to_string();
459        Ok(Package::Object(HashMap::from([(key, value)])))
460    }
461
462    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
463        let len = len.unwrap_or(0);
464        Ok(CompoundArray { name: None, data: Vec::with_capacity(len) })
465    }
466
467    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
468        Ok(CompoundArray { name: None, data: Vec::with_capacity(len) })
469    }
470
471    fn serialize_tuple_struct(
472        self,
473        name: &'static str,
474        len: usize,
475    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
476        Ok(CompoundArray { name: Some(name.to_owned()), data: Vec::with_capacity(len) })
477    }
478
479    fn serialize_tuple_variant(
480        self,
481        _name: &'static str,
482        _variant_index: u32,
483        variant: &'static str,
484        len: usize,
485    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
486        Ok(CompoundArray { name: Some(variant.to_string()), data: Vec::with_capacity(len) })
487    }
488
489    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
490        let len = len.unwrap_or(0);
491        Ok(CompoundObjects { name: None, data: HashMap::with_capacity(len) })
492    }
493
494    fn serialize_struct(
495        self,
496        _name: &'static str,
497        len: usize,
498    ) -> Result<Self::SerializeStruct, Self::Error> {
499        Ok(CompoundObjects { name: None, data: HashMap::with_capacity(len) })
500    }
501
502    fn serialize_struct_variant(
503        self,
504        _name: &'static str,
505        _variant_index: u32,
506        variant: &'static str,
507        len: usize,
508    ) -> Result<Self::SerializeStructVariant, Self::Error> {
509        Ok(CompoundObjects { name: Some(variant.to_string()), data: HashMap::with_capacity(len) })
510    }
511} 
512
513
514impl SerializeSeq for CompoundArray {
515    type Ok = Package;
516    type Error = PackageSerializerError;
517
518    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
519    where
520        T: serde::Serialize {
521        let value = value.serialize(PackageSerializer)?;
522        self.data.push(value);
523        Ok(())
524    }
525
526    fn end(self) -> Result<Self::Ok, Self::Error> {
527        Ok(Package::Array(self.data))
528    }
529}
530
531impl SerializeTuple for CompoundArray {
532    type Ok = Package;
533    type Error = PackageSerializerError;
534
535    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
536    where
537        T: serde::Serialize {
538        let value = value.serialize(PackageSerializer)?;
539        self.data.push(value);
540        Ok(())
541    }
542
543    fn end(self) -> Result<Self::Ok, Self::Error> {
544        Ok(Package::Array(self.data))
545    }
546}
547
548impl SerializeTupleStruct for CompoundArray {
549    type Ok = Package;
550    type Error = PackageSerializerError;
551
552    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
553    where
554        T: serde::Serialize {
555        let value = value.serialize(PackageSerializer)?;
556        self.data.push(value);
557        Ok(())
558    }
559
560    fn end(self) -> Result<Self::Ok, Self::Error> {
561        if let Some(name) = self.name {
562            let data = Package::Array(self.data);
563            let data = HashMap::from([(name, data)]);
564            Ok(Package::Object(data))
565        } else {
566            Err(PackageSerializerError { cause: "Cannot serialize a Tuple Struct without the name".to_string() })
567        }
568    }
569}
570
571impl SerializeTupleVariant for CompoundArray {
572    type Ok = Package;
573    type Error = PackageSerializerError;
574
575    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
576    where
577        T: serde::Serialize {
578        let value = value.serialize(PackageSerializer)?;
579        self.data.push(value);
580        Ok(())
581    }
582
583    fn end(self) -> Result<Self::Ok, Self::Error> {
584        if let Some(name) = self.name {
585            let data = Package::Array(self.data);
586            let data = HashMap::from([(name, data)]);
587            Ok(Package::Object(data))
588        } else {
589            Err(PackageSerializerError { cause: "Cannot serialize a Tuple variant without the name".to_string() })
590        }
591    }
592}
593
594impl SerializeMap for CompoundObjects {
595    type Ok = Package;
596    type Error = PackageSerializerError;
597
598    fn serialize_entry<K: ?Sized, V: ?Sized>(
599            &mut self,
600            key: &K,
601            value: &V,
602        ) -> Result<(), Self::Error>
603        where
604            K: serde::Serialize,
605            V: serde::Serialize, 
606    {
607        let key = key.serialize(MapKeySerializer)?;
608        let value = value.serialize(PackageSerializer)?;
609        self.data.insert(key, value);
610        Ok(())
611    }
612
613    fn end(self) -> Result<Self::Ok, Self::Error> {
614        Ok(Package::Object(self.data))
615    }
616    
617    fn serialize_key<T: ?Sized>(&mut self, _key: &T) -> Result<(), Self::Error>
618    where
619        T: serde::Serialize {
620        unimplemented!()
621    }
622    fn serialize_value<T: ?Sized>(&mut self, _value: &T) -> Result<(), Self::Error>
623    where
624        T: serde::Serialize {
625        unimplemented!()
626    }
627}
628
629impl SerializeStruct for CompoundObjects {
630    type Ok = Package;
631    type Error = PackageSerializerError;
632
633    fn serialize_field<T: ?Sized>(
634        &mut self,
635        key: &'static str,
636        value: &T,
637    ) -> Result<(), Self::Error>
638    where
639        T: serde::Serialize {
640        let value = value.serialize(PackageSerializer)?;
641        self.data.insert(key.to_owned(), value);
642        Ok(())
643    }
644
645    fn end(self) -> Result<Self::Ok, Self::Error> {
646        Ok(Package::Object(HashMap::from(self.data)))
647    }
648}
649
650impl SerializeStructVariant for CompoundObjects {
651    type Ok = Package;
652    type Error = PackageSerializerError;
653
654    fn serialize_field<T: ?Sized>(
655        &mut self,
656        key: &'static str,
657        value: &T,
658    ) -> Result<(), Self::Error>
659    where
660        T: serde::Serialize {
661        let value = value.serialize(PackageSerializer)?;
662        self.data.insert(key.to_owned(), value);
663        Ok(())
664    }
665
666    fn end(self) -> Result<Self::Ok, Self::Error> {
667        if let Some(name) = self.name {
668            let data = Package::Object(HashMap::from(self.data));
669            let data = Package::Object(HashMap::from([(name, data)]));
670            return Ok(data);
671        }
672        Ok(Package::Object(HashMap::from(self.data)))
673    }
674}
675
676// endregion
rs_flow/package/serde/serializer.rs

rs_flow/package/serde/
serializer.rs
