serde_dynamodb_streams/dynamodbstreams/
ser.rs

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

serde_dynamodb_streams/dynamodbstreams/
ser.rs
