rs_flow/package/serde/
deserializer.rs

1use std::{collections::{hash_map::IntoIter, HashMap}, fmt::Display};
2
3use serde::{
4    de::{
5        DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess, SeqAccess, VariantAccess
6    }, 
7    Deserialize, 
8    Deserializer
9};
10use thiserror::Error;
11
12use crate::package::{error::PackageError, Package};
13
14#[derive(Debug, Error)]
15#[error("Package could not be deserialized, cause: {cause:?}")]
16pub struct PackageDeserializerError {
17    cause: String
18}
19
20impl From<PackageError> for PackageDeserializerError {
21    fn from(value: PackageError) -> Self {
22        Self { cause: value.to_string() }
23    }
24}
25
26impl serde::de::Error for PackageDeserializerError {
27    fn custom<T: Display>(msg: T) -> Self {
28        Self { cause: msg.to_string() }
29    }
30}
31
32
33pub fn deserialize<T: for<'a> Deserialize<'a>>(package: Package) -> 
34    Result<T, PackageDeserializerError> 
35{
36    T::deserialize(package)
37}
38
39
40// region: impl Deserializer
41
42impl<'de> Deserializer<'de> for Package {
43    type Error = PackageDeserializerError;
44
45    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
46    where
47        V: serde::de::Visitor<'de> 
48    {
49        match self {
50            Package::Empty => self.deserialize_unit(visitor),
51            Package::Number(_) => self.deserialize_f64(visitor),
52            Package::String(_) => self.deserialize_string(visitor),
53            Package::Boolean(_) => self.deserialize_bool(visitor),
54            Package::Bytes(_) => self.deserialize_bytes(visitor),
55            Package::Array(_) => self.deserialize_seq(visitor),
56            Package::Object(_) => self.deserialize_map(visitor)
57        }
58    }
59
60    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
61    where
62        V: serde::de::Visitor<'de> {
63        let value = self.get_bool()?;
64        visitor.visit_bool(value)
65    }
66
67    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
68    where
69        V: serde::de::Visitor<'de> {
70        let value = self.get_number()? as i8;
71        visitor.visit_i8(value)
72    }
73
74    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
75    where
76        V: serde::de::Visitor<'de> {
77        let value = self.get_number()? as i16;
78        visitor.visit_i16(value)
79    }
80
81    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
82    where
83        V: serde::de::Visitor<'de> {
84            let value = self.get_number()? as i32;
85            visitor.visit_i32(value)
86    }
87
88    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
89    where
90        V: serde::de::Visitor<'de> {
91        let value = self.get_number()? as i64;
92        visitor.visit_i64(value)
93    }
94
95    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
96    where
97        V: serde::de::Visitor<'de> {
98        let value = self.get_number()? as u8;
99        visitor.visit_u8(value)
100    }
101
102    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
103    where
104        V: serde::de::Visitor<'de> {
105        let value = self.get_number()? as u16;
106        visitor.visit_u16(value)
107    }
108
109    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
110    where
111        V: serde::de::Visitor<'de> {
112        let value = self.get_number()? as u32;
113        visitor.visit_u32(value)
114    }
115
116    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
117    where
118        V: serde::de::Visitor<'de> {
119        let value = self.get_number()? as u64;
120        visitor.visit_u64(value)
121    }
122
123    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
124    where
125        V: serde::de::Visitor<'de> {
126        let value = self.get_number()? as f32;
127        visitor.visit_f32(value)
128    }
129
130    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
131    where
132        V: serde::de::Visitor<'de> {
133        let value = self.get_number()?;
134        visitor.visit_f64(value)
135    }
136
137    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
138    where
139        V: serde::de::Visitor<'de> {
140        let string = self.get_string()?;
141        let mut chars = string.chars();
142        if let (Some(char), None) = (chars.next(), chars.next()){
143            visitor.visit_char(char)
144        } else {
145            Err(PackageDeserializerError { cause: "Not a char".to_owned() })
146        }
147    }
148
149    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
150    where
151        V: serde::de::Visitor<'de> {
152        let value = self.get_string()?;
153        visitor.visit_str(&value)
154    }
155
156    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
157    where
158        V: serde::de::Visitor<'de> {
159        let value = self.get_string()?;
160        visitor.visit_string(value)
161    }
162
163    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
164    where
165        V: serde::de::Visitor<'de> {
166        let value = self.get_bytes()?;
167        visitor.visit_bytes(&value)
168    }
169
170    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
171    where
172        V: serde::de::Visitor<'de> {
173        let value = self.get_bytes()?;
174        visitor.visit_byte_buf(value)
175    }
176
177    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
178    where
179        V: serde::de::Visitor<'de> {
180        if self.is_empty() {
181            visitor.visit_none()
182        } else {
183            visitor.visit_some(self)
184        }
185    }
186
187    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
188    where
189        V: serde::de::Visitor<'de> {
190        self.get_empty()?;
191        visitor.visit_unit()
192    }
193
194    fn deserialize_unit_struct<V>(
195        self,
196        name: &'static str,
197        visitor: V,
198    ) -> Result<V::Value, Self::Error>
199    where
200        V: serde::de::Visitor<'de> {
201        let value = self.get_string()?;
202        if name == value {
203            visitor.visit_unit()
204        } else {
205            Err(PackageDeserializerError { cause: format!("Expect '{name}' but found '{value}'") })
206        }
207    }
208
209    fn deserialize_newtype_struct<V>(
210        self,
211        name: &'static str,
212        visitor: V,
213    ) -> Result<V::Value, Self::Error>
214    where
215        V: serde::de::Visitor<'de> {
216        let mut value = self.get_object()?;
217        if value.len() == 1  {
218            if let Some(package) = value.remove(name) {
219                visitor.visit_newtype_struct(package)
220            } else {
221                Err(PackageDeserializerError { cause: format!("Object cannot be parsed into struct '{name}' because not have that entry") })
222            }
223        } else {
224            Err(PackageDeserializerError { cause: format!("Object cannot be parsed into struct '{name}' because not have a unique entry") })
225        }
226    }
227
228    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
229    where
230        V: serde::de::Visitor<'de> {
231        visitor.visit_seq(DiscompoundArray::create(self, None, None)?)
232    }
233
234    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
235    where
236        V: serde::de::Visitor<'de> {
237        visitor.visit_seq(DiscompoundArray::create(self, None, Some(len))?)
238    }
239
240    fn deserialize_tuple_struct<V>(
241        self,
242        name: &'static str,
243        len: usize,
244        visitor: V,
245    ) -> Result<V::Value, Self::Error>
246    where
247        V: serde::de::Visitor<'de> {
248        visitor.visit_seq(DiscompoundArray::create(self, Some(name), Some(len))?)
249    }
250
251    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
252    where
253        V: serde::de::Visitor<'de> {
254        let object = self.get_object()?;
255        visitor.visit_map(DiscompoundObject::create(object))
256    }
257
258    fn deserialize_struct<V>(
259        self,
260        _name: &'static str,
261        _fields: &'static [&'static str],
262        visitor: V,
263    ) -> Result<V::Value, Self::Error>
264    where
265        V: serde::de::Visitor<'de> {
266        let object = self.get_object()?;
267        visitor.visit_map(DiscompoundObject::create(object))
268    }
269
270    fn deserialize_enum<V>(
271        self,
272        _name: &'static str,
273        _variants: &'static [&'static str],
274        visitor: V,
275    ) -> Result<V::Value, Self::Error>
276    where
277        V: serde::de::Visitor<'de> 
278    {
279        let (variant, value) = match self {
280            Package::Object(value) => {
281                let mut iter = value.into_iter();
282                let (variant, value) = match iter.next() {
283                    Some(v) => v,
284                    None => {
285                        return Err(PackageDeserializerError { 
286                            cause: "Expect object with a single key".to_owned()
287                        });
288                    }
289                };
290                // enums are encoded in json as maps with a single key:value pair
291                if iter.next().is_some() {
292                    return Err(PackageDeserializerError { 
293                        cause: "Expect object with a single key".to_owned()
294                    });
295                }
296                (variant, Some(value))
297            },
298
299            Package::String(variant) => (variant, None),
300
301            _ => {
302                return Err(PackageDeserializerError { 
303                    cause: "Expect string or object".to_owned()
304                });
305            }
306        };
307
308        visitor.visit_enum(EnumDeserializer { variant, value })
309    }
310
311    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
312    where
313        V: serde::de::Visitor<'de> {
314        self.deserialize_str(visitor)
315    }
316
317    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
318    where
319        V: serde::de::Visitor<'de> {
320        self.deserialize_any(visitor)
321    }
322}
323
324struct EnumDeserializer {
325    variant: String,
326    value: Option<Package>,
327}
328impl<'de> EnumAccess<'de> for EnumDeserializer {
329    type Error = PackageDeserializerError;
330    type Variant = VariantDeserializer;
331
332    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Self::Error>
333    where
334        V: DeserializeSeed<'de>,
335    {
336        let variant = self.variant.into_deserializer();
337        let visitor = VariantDeserializer { value: self.value };
338        seed.deserialize(variant).map(|v| (v, visitor))
339    }
340}
341
342struct VariantDeserializer {
343    value: Option<Package>,
344}
345
346impl<'de> VariantAccess<'de> for VariantDeserializer {
347    type Error = PackageDeserializerError;
348
349    fn unit_variant(self) -> Result<(), Self::Error> {
350        match self.value {
351            Some(value) => Deserialize::deserialize(value),
352            None => Ok(()),
353        }
354    }
355
356    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
357    where
358        T: DeserializeSeed<'de> {
359        match self.value {
360            Some(value) => seed.deserialize(value),
361            None => {
362                Err(PackageDeserializerError { 
363                    cause: "Expect type variant".to_owned()
364                })
365            }
366        }
367    }
368
369    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
370    where
371        V: serde::de::Visitor<'de> {
372        match self.value {
373            Some(package) => {
374                visitor.visit_seq(DiscompoundArray::create(package, None, Some(len))?)
375            }
376            _ => {
377                Err(PackageDeserializerError { 
378                    cause: "Expect tuple variant".to_owned()
379                })
380            }
381        }
382    }
383
384    fn struct_variant<V>(
385        self,
386        _fields: &'static [&'static str],
387        visitor: V,
388    ) -> Result<V::Value, Self::Error>
389    where
390        V: serde::de::Visitor<'de> {
391        match self.value {
392            Some(Package::Object(object)) => {
393                visitor.visit_map(DiscompoundObject::create(object))
394            }
395            _ => {
396                Err(PackageDeserializerError { 
397                    cause: "Expect struct variant".to_owned()
398                })
399            }
400        }
401    }
402}
403
404struct DiscompoundArray {
405    data: Vec<Package>
406}
407impl DiscompoundArray {
408    pub fn create(package: Package, name: Option<&'static str>, len: Option<usize>) -> 
409        Result<Self, PackageDeserializerError>
410    {   
411        let package = if let Some(name) = name {
412            let mut value = package.get_object()?; 
413
414            if value.len() == 1  {
415                if let Some(package) = value.remove(name) {
416                    package
417                } else {
418                    return Err(PackageDeserializerError { cause: format!("Object cannot be parsed into '{name}' because not have that entry") })
419                }
420            } else {
421                return Err(PackageDeserializerError { cause: format!("Object cannot be parsed into '{name}' because not have a unique entry") })
422            }
423        } else {
424            package
425        };
426
427
428        let mut package = package.get_array()?;
429        if let Some(len) = len {
430            if len != package.len() {
431                return Err(PackageDeserializerError { 
432                    cause: format!("Required a array with length '{len}', but found '{}'", package.len() )
433                })
434            }
435        }
436
437        package.reverse();
438        Ok(
439            Self { data: package }
440        )
441    }
442}
443
444
445impl<'de> SeqAccess<'de> for DiscompoundArray {
446    type Error = PackageDeserializerError;
447
448    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
449    where
450        T: serde::de::DeserializeSeed<'de> 
451    {
452        if let Some(package) = self.data.pop() {
453            let value = seed.deserialize(package)?;
454            Ok(Some(value))
455        } else {
456            Ok(None)
457        }
458    }
459}
460
461struct DiscompoundObject {
462    data: IntoIter<String, Package>,
463    last: Option<Package>
464}
465
466impl DiscompoundObject {
467    pub fn create(object: HashMap<String, Package>) -> Self {
468        Self { data: object.into_iter(), last: None }
469    }
470}
471impl<'de> MapAccess<'de> for DiscompoundObject {
472    type Error = PackageDeserializerError;
473
474    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
475    where
476        K: DeserializeSeed<'de> {
477        match self.data.next() {
478            Some((key, value)) => {
479                let key = seed.deserialize(MapKeyDeserializer { key })?;
480                self.last = Some(value);
481
482                Ok(Some(key))
483            },
484            None => Ok(None),
485        }
486        
487    }
488
489    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
490    where
491        V: DeserializeSeed<'de> {
492        match self.last.take() {
493            Some(value) => seed.deserialize(value),
494            None => Err(PackageDeserializerError { 
495                cause: "Value is missing".to_owned()
496            }),
497        }
498    }
499}
500// endregion
501
502// region: impl MapKeyDeserializer
503
504struct MapKeyDeserializer {
505    key: String
506}
507
508impl<'de> Deserializer<'de> for MapKeyDeserializer {
509    type Error = PackageDeserializerError;
510
511    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
512    where
513        V: serde::de::Visitor<'de> {
514        Err(PackageDeserializerError { cause: "Key could not be parsed".to_owned() })   
515    }
516
517    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
518    where
519        V: serde::de::Visitor<'de> {
520        let key = self.key.parse::<bool>().map_err(|e| 
521            PackageDeserializerError { cause: e.to_string() 
522        })?;
523        visitor.visit_bool(key)
524    }
525
526    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
527    where
528        V: serde::de::Visitor<'de> {
529        let key = self.key.parse::<i8>().map_err(|e| 
530            PackageDeserializerError { cause: e.to_string() 
531        })?;
532        visitor.visit_i8(key)
533    }
534
535    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
536    where
537        V: serde::de::Visitor<'de> {
538        let key = self.key.parse::<i16>().map_err(|e| 
539            PackageDeserializerError { cause: e.to_string() 
540        })?;
541        visitor.visit_i16(key)
542    }
543
544    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
545    where
546        V: serde::de::Visitor<'de> {
547        let key = self.key.parse::<i32>().map_err(|e| 
548            PackageDeserializerError { cause: e.to_string() 
549        })?;
550        visitor.visit_i32(key)
551    }
552
553    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
554    where
555        V: serde::de::Visitor<'de> {
556        let key = self.key.parse::<i64>().map_err(|e| 
557            PackageDeserializerError { cause: e.to_string() 
558        })?;
559        visitor.visit_i64(key)
560    }
561
562    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
563    where
564        V: serde::de::Visitor<'de> {
565        let key = self.key.parse::<u8>().map_err(|e| 
566            PackageDeserializerError { cause: e.to_string() 
567        })?;
568        visitor.visit_u8(key)
569    }
570
571    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
572    where
573        V: serde::de::Visitor<'de> {
574        let key = self.key.parse::<u16>().map_err(|e| 
575            PackageDeserializerError { cause: e.to_string() 
576        })?;
577        visitor.visit_u16(key)
578    }
579
580    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
581    where
582        V: serde::de::Visitor<'de> {
583        let key = self.key.parse::<u32>().map_err(|e| 
584            PackageDeserializerError { cause: e.to_string() 
585        })?;
586        visitor.visit_u32(key)
587    }
588
589    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
590    where
591        V: serde::de::Visitor<'de> {
592        let key = self.key.parse::<u64>().map_err(|e| 
593            PackageDeserializerError { cause: e.to_string() 
594        })?;
595        visitor.visit_u64(key)
596    }
597
598    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
599    where
600        V: serde::de::Visitor<'de> {
601        let key = self.key.parse::<f32>().map_err(|e| 
602            PackageDeserializerError { cause: e.to_string() 
603        })?;
604        visitor.visit_f32(key)
605    }
606
607    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
608    where
609        V: serde::de::Visitor<'de> {
610        let key = self.key.parse::<f64>().map_err(|e| 
611            PackageDeserializerError { cause: e.to_string() 
612        })?;
613        visitor.visit_f64(key)
614    }
615
616    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
617    where
618        V: serde::de::Visitor<'de> {
619        let key = self.key.parse::<char>().map_err(|e| 
620            PackageDeserializerError { cause: e.to_string() 
621        })?;
622        visitor.visit_char(key)
623    }
624
625    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
626    where
627        V: serde::de::Visitor<'de> {
628        visitor.visit_str(&self.key)
629    }
630
631    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
632    where
633        V: serde::de::Visitor<'de> {
634        visitor.visit_string(self.key)
635    }
636
637    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
638    where
639        V: serde::de::Visitor<'de> {
640        Err(PackageDeserializerError { cause: "Key could not be parsed".to_owned() })
641    }
642
643    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
644    where
645        V: serde::de::Visitor<'de> {
646        Err(PackageDeserializerError { cause: "Key could not be parsed".to_owned() })
647    }
648
649    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
650    where
651        V: serde::de::Visitor<'de> {
652        if self.key == "" {
653            visitor.visit_none()
654        } else {
655            visitor.visit_some(self)
656        }
657    }
658
659    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
660    where
661        V: serde::de::Visitor<'de> {
662        if self.key == "" {
663            visitor.visit_unit()
664        } else {
665            Err(PackageDeserializerError { cause: "Key could not be parsed".to_owned() })
666        }
667    }
668
669    fn deserialize_unit_struct<V>(
670        self,
671        name: &'static str,
672        visitor: V,
673    ) -> Result<V::Value, Self::Error>
674    where
675        V: serde::de::Visitor<'de> {
676        if self.key == name {
677            visitor.visit_unit()
678        } else {
679            Err(PackageDeserializerError { cause: "Key could not be parsed".to_owned() })
680        }
681    }
682
683    fn deserialize_newtype_struct<V>(
684        self,
685        _name: &'static str,
686        _visitor: V,
687    ) -> Result<V::Value, Self::Error>
688    where
689        V: serde::de::Visitor<'de> {
690        Err(PackageDeserializerError { cause: "Key could not be parsed".to_owned() })
691    }
692
693    fn deserialize_seq<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
694    where
695        V: serde::de::Visitor<'de> {
696        Err(PackageDeserializerError { cause: "Key could not be parsed".to_owned() })
697    }
698
699    fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
700    where
701        V: serde::de::Visitor<'de> {
702        Err(PackageDeserializerError { cause: "Key could not be parsed".to_owned() })
703    }
704
705    fn deserialize_tuple_struct<V>(
706        self,
707        _name: &'static str,
708        _len: usize,
709        _visitor: V,
710    ) -> Result<V::Value, Self::Error>
711    where
712        V: serde::de::Visitor<'de> {
713        Err(PackageDeserializerError { cause: "Key could not be parsed".to_owned() })
714    }
715
716    fn deserialize_map<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
717    where
718        V: serde::de::Visitor<'de> {
719        Err(PackageDeserializerError { cause: "Key could not be parsed".to_owned() })
720    }
721
722    fn deserialize_struct<V>(
723        self,
724        _name: &'static str,
725        _fields: &'static [&'static str],
726        _visitor: V,
727    ) -> Result<V::Value, Self::Error>
728    where
729        V: serde::de::Visitor<'de> {
730        Err(PackageDeserializerError { cause: "Key could not be parsed".to_owned() })
731    }
732
733    fn deserialize_enum<V>(
734        self,
735        _name: &'static str,
736        _variants: &'static [&'static str],
737        _visitor: V,
738    ) -> Result<V::Value, Self::Error>
739    where
740        V: serde::de::Visitor<'de> {
741        Err(PackageDeserializerError { cause: "Key could not be parsed".to_owned() })
742    }
743
744    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
745    where
746        V: serde::de::Visitor<'de> {
747        self.deserialize_str(visitor)
748    }
749
750    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
751    where
752        V: serde::de::Visitor<'de> {
753        Err(PackageDeserializerError { cause: "Key could not be parsed".to_owned() })
754    }
755}
756// endregion
rs_flow/package/serde/deserializer.rs

rs_flow/package/serde/
deserializer.rs
