serde_dynamo/ser/
serializer.rs

1use super::{
2    AttributeValue, Error, SerializerMap, SerializerSeq, SerializerStruct, SerializerStructVariant,
3    SerializerTupleVariant,
4};
5use serde::{ser, Serialize};
6use std::collections::HashMap;
7
8/// A structure for serializing Rust values into [`AttributeValue`]s.
9#[derive(Copy, Clone, Debug, Default)]
10pub struct Serializer;
11
12impl ser::Serializer for Serializer {
13    type Ok = AttributeValue;
14    type Error = Error;
15
16    type SerializeSeq = SerializerSeq;
17    type SerializeTuple = SerializerSeq;
18    type SerializeTupleStruct = SerializerSeq;
19    type SerializeTupleVariant = SerializerTupleVariant;
20    type SerializeMap = SerializerMap;
21    type SerializeStruct = SerializerStruct;
22    type SerializeStructVariant = SerializerStructVariant;
23
24    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
25        Ok(AttributeValue::N(v.to_string()))
26    }
27    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
28        Ok(AttributeValue::N(v.to_string()))
29    }
30    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
31        Ok(AttributeValue::N(v.to_string()))
32    }
33    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
34        Ok(AttributeValue::N(v.to_string()))
35    }
36    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
37        Ok(AttributeValue::N(v.to_string()))
38    }
39    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
40        Ok(AttributeValue::N(v.to_string()))
41    }
42    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
43        Ok(AttributeValue::N(v.to_string()))
44    }
45    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
46        Ok(AttributeValue::N(v.to_string()))
47    }
48    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
49        Ok(AttributeValue::N(v.to_string()))
50    }
51    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
52        Ok(AttributeValue::N(v.to_string()))
53    }
54    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
55        Ok(AttributeValue::S(v.to_string()))
56    }
57    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
58        let serializer = SerializerSeq::new(len);
59        Ok(serializer)
60    }
61    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
62        let serializer = SerializerMap::new(len);
63        Ok(serializer)
64    }
65    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
66        Ok(AttributeValue::Bool(v))
67    }
68    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
69        Ok(AttributeValue::S(v.to_string()))
70    }
71    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
72        Ok(AttributeValue::Null(true))
73    }
74    fn serialize_some<V: ?Sized>(self, value: &V) -> Result<Self::Ok, Self::Error>
75    where
76        V: Serialize,
77    {
78        value.serialize(self)
79    }
80    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
81        Ok(AttributeValue::Null(true))
82    }
83    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
84        Ok(AttributeValue::B(v.to_vec()))
85    }
86    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
87        let serializer = SerializerSeq::new(Some(len));
88        Ok(serializer)
89    }
90    fn serialize_struct(
91        self,
92        _name: &'static str,
93        len: usize,
94    ) -> Result<Self::SerializeStruct, Self::Error> {
95        let serializer = SerializerStruct::new(len);
96        Ok(serializer)
97    }
98    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
99        Ok(AttributeValue::Null(true))
100    }
101    fn serialize_unit_variant(
102        self,
103        _name: &'static str,
104        _variant_index: u32,
105        variant: &'static str,
106    ) -> Result<Self::Ok, Self::Error> {
107        Ok(AttributeValue::S(variant.to_string()))
108    }
109    fn serialize_tuple_struct(
110        self,
111        _name: &'static str,
112        len: usize,
113    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
114        let serializer = SerializerSeq::new(Some(len));
115        Ok(serializer)
116    }
117    fn serialize_tuple_variant(
118        self,
119        _name: &'static str,
120        _variant_index: u32,
121        variant: &'static str,
122        len: usize,
123    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
124        let serializer = SerializerTupleVariant::new(variant, len);
125        Ok(serializer)
126    }
127    fn serialize_newtype_struct<V: ?Sized>(
128        self,
129        name: &'static str,
130        value: &V,
131    ) -> Result<Self::Ok, Self::Error>
132    where
133        V: Serialize,
134    {
135        let av = value.serialize(self)?;
136
137        if crate::string_set::should_serialize_as_string_set(name) {
138            crate::string_set::convert_to_set(av)
139        } else if crate::number_set::should_serialize_as_numbers_set(name) {
140            crate::number_set::convert_to_set(av)
141        } else if crate::binary_set::should_serialize_as_binary_set(name) {
142            crate::binary_set::convert_to_set(av)
143        } else {
144            Ok(av)
145        }
146    }
147    fn serialize_struct_variant(
148        self,
149        _name: &'static str,
150        _variant_index: u32,
151        variant: &'static str,
152        len: usize,
153    ) -> Result<Self::SerializeStructVariant, Self::Error> {
154        let serializer = SerializerStructVariant::new(variant, len);
155        Ok(serializer)
156    }
157    fn serialize_newtype_variant<V: ?Sized>(
158        self,
159        _name: &'static str,
160        _variant_index: u32,
161        variant: &'static str,
162        value: &V,
163    ) -> Result<Self::Ok, Self::Error>
164    where
165        V: Serialize,
166    {
167        let serializer = Serializer;
168        let av = value.serialize(serializer)?;
169        let mut item = HashMap::new();
170        item.insert(variant.to_string(), av);
171        Ok(AttributeValue::M(item))
172    }
173}
serde_dynamo/ser/serializer.rs

serde_dynamo/ser/
serializer.rs
