firestore_serde/serialize/
mod.rs

1pub use self::error::{Result, SerializationError};
2use self::timestamp_serializer::TimestampSerializer;
3use self::{
4    array_builder::ArrayBuilder, kv_map_builder::KVMapBuilder, map_builder::MapBuilder,
5    named_array_builder::NamedArrayBuilder, named_map_builder::NamedMapBuilder,
6};
7use crate::firestore::{value::ValueType, MapValue, Value};
8use crate::{DATE_MAGIC, TYPE, VALUE};
9use serde::{Serialize, Serializer};
10use std::convert::TryFrom;
11
12mod array_builder;
13mod error;
14mod kv_map_builder;
15mod map_builder;
16mod named_array_builder;
17mod named_map_builder;
18mod timestamp_serializer;
19
20pub struct ValueSerializer;
21
22impl Serializer for ValueSerializer {
23    type Ok = Value;
24
25    type Error = SerializationError;
26
27    type SerializeMap = KVMapBuilder;
28    type SerializeSeq = ArrayBuilder;
29    type SerializeStruct = MapBuilder;
30    type SerializeStructVariant = NamedMapBuilder;
31    type SerializeTuple = ArrayBuilder;
32    type SerializeTupleStruct = ArrayBuilder;
33    type SerializeTupleVariant = NamedArrayBuilder;
34
35    fn serialize_bool(self, v: bool) -> Result<Value> {
36        Ok(Value {
37            value_type: Some(ValueType::BooleanValue(v)),
38        })
39    }
40
41    fn serialize_i8(self, v: i8) -> Result<Value> {
42        Ok(Value {
43            value_type: Some(ValueType::IntegerValue(i64::from(v))),
44        })
45    }
46
47    fn serialize_i16(self, v: i16) -> Result<Value> {
48        Ok(Value {
49            value_type: Some(ValueType::IntegerValue(i64::from(v))),
50        })
51    }
52
53    fn serialize_i32(self, v: i32) -> Result<Value> {
54        Ok(Value {
55            value_type: Some(ValueType::IntegerValue(i64::from(v))),
56        })
57    }
58
59    fn serialize_i64(self, v: i64) -> Result<Value> {
60        Ok(Value {
61            value_type: Some(ValueType::IntegerValue(v)),
62        })
63    }
64
65    fn serialize_u8(self, v: u8) -> Result<Value> {
66        Ok(Value {
67            value_type: Some(ValueType::IntegerValue(i64::from(v))),
68        })
69    }
70
71    fn serialize_u16(self, v: u16) -> Result<Value> {
72        Ok(Value {
73            value_type: Some(ValueType::IntegerValue(i64::from(v))),
74        })
75    }
76
77    fn serialize_u32(self, v: u32) -> Result<Value> {
78        Ok(Value {
79            value_type: Some(ValueType::IntegerValue(i64::from(v))),
80        })
81    }
82
83    fn serialize_u64(self, v: u64) -> Result<Value> {
84        Ok(Value {
85            value_type: Some(ValueType::IntegerValue(
86                i64::try_from(v).map_err(|_| SerializationError::OutsideIntRange(v))?,
87            )),
88        })
89    }
90
91    fn serialize_f32(self, v: f32) -> Result<Value> {
92        Ok(Value {
93            value_type: Some(ValueType::DoubleValue(f64::from(v))),
94        })
95    }
96
97    fn serialize_f64(self, v: f64) -> Result<Value> {
98        Ok(Value {
99            value_type: Some(ValueType::DoubleValue(v)),
100        })
101    }
102
103    fn serialize_char(self, v: char) -> Result<Value> {
104        Ok(Value {
105            value_type: Some(ValueType::StringValue(v.to_string())),
106        })
107    }
108
109    fn serialize_str(self, v: &str) -> Result<Value> {
110        Ok(Value {
111            value_type: Some(ValueType::StringValue(v.to_string())),
112        })
113    }
114
115    fn serialize_bytes(self, v: &[u8]) -> Result<Value> {
116        Ok(Value {
117            value_type: Some(ValueType::BytesValue(v.into())),
118        })
119    }
120
121    fn serialize_none(self) -> Result<Value> {
122        Ok(Value {
123            value_type: Some(ValueType::NullValue(0)),
124        })
125    }
126
127    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Value>
128    where
129        T: Serialize,
130    {
131        value.serialize(self)
132    }
133
134    fn serialize_unit(self) -> Result<Value> {
135        Err(SerializationError::Unrepresentable("()".to_string()))
136    }
137
138    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
139        Err(SerializationError::Unrepresentable(
140            "unit_struct".to_string(),
141        ))
142    }
143
144    fn serialize_unit_variant(
145        self,
146        _name: &'static str,
147        _variant_index: u32,
148        variant: &'static str,
149    ) -> Result<Value> {
150        Ok(Value {
151            value_type: Some(ValueType::StringValue(variant.to_string())),
152        })
153    }
154
155    fn serialize_newtype_struct<T: ?Sized>(self, name: &'static str, value: &T) -> Result<Value>
156    where
157        T: Serialize,
158    {
159        if name == DATE_MAGIC {
160            value.serialize(TimestampSerializer)
161        } else {
162            value.serialize(self)
163        }
164    }
165
166    fn serialize_newtype_variant<T: ?Sized>(
167        self,
168        _name: &'static str,
169        _variant_index: u32,
170        variant: &'static str,
171        value: &T,
172    ) -> Result<Value>
173    where
174        T: Serialize,
175    {
176        Ok(Value {
177            value_type: Some(ValueType::MapValue(MapValue {
178                fields: vec![
179                    (TYPE.to_string(), variant.serialize(ValueSerializer)?),
180                    (VALUE.to_string(), value.serialize(ValueSerializer)?),
181                ]
182                .into_iter()
183                .collect(),
184            })),
185        })
186    }
187
188    fn serialize_seq(self, len: Option<usize>) -> Result<ArrayBuilder> {
189        let builder = if let Some(len) = len {
190            ArrayBuilder::with_capacity(len)
191        } else {
192            ArrayBuilder::default()
193        };
194
195        Ok(builder)
196    }
197
198    fn serialize_tuple(self, len: usize) -> Result<ArrayBuilder> {
199        Ok(ArrayBuilder::with_capacity(len))
200    }
201
202    fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<ArrayBuilder> {
203        Ok(ArrayBuilder::with_capacity(len))
204    }
205
206    fn serialize_tuple_variant(
207        self,
208        _name: &'static str,
209        _variant_index: u32,
210        variant: &'static str,
211        len: usize,
212    ) -> Result<NamedArrayBuilder> {
213        Ok(NamedArrayBuilder::with_capacity(variant.to_string(), len))
214    }
215
216    fn serialize_map(self, len: Option<usize>) -> Result<KVMapBuilder> {
217        if let Some(len) = len {
218            Ok(KVMapBuilder::with_capacity(len))
219        } else {
220            Ok(KVMapBuilder::default())
221        }
222    }
223
224    fn serialize_struct(self, _name: &'static str, len: usize) -> Result<MapBuilder> {
225        Ok(MapBuilder::with_capacity(len))
226    }
227
228    fn serialize_struct_variant(
229        self,
230        _name: &'static str,
231        _variant_index: u32,
232        variant: &'static str,
233        len: usize,
234    ) -> Result<NamedMapBuilder> {
235        Ok(NamedMapBuilder::with_capacity(variant.to_string(), len))
236    }
237}
firestore_serde/serialize/mod.rs

firestore_serde/serialize/
mod.rs
