serde_firestore_value/ser/
firestore_value_serializer.rs

1use serde::{Serialize, Serializer};
2
3use crate::google::firestore::v1::Value;
4use crate::{
5    error::ErrorCode,
6    ser::{
7        firestore_array_value_serializer::FirestoreArrayValueSerializer,
8        firestore_map_value_serializer::FirestoreMapValueSerializer,
9    },
10    value_ext::ValueExt,
11    Reference,
12};
13
14use super::{
15    firestore_reference_value_serializer::FirestoreReferenceValueSerializer,
16    firestore_value_struct_serializer::FirestoreValueStructSerializer,
17    name_map_value_serializer::NameMapValueSerializer, Error,
18};
19
20/// A Serializer type which implements [`serde::Serializer`] for [`Value`].
21#[derive(Debug)]
22pub struct FirestoreValueSerializer;
23
24// 1,048,487 bytes = 1MiB - 89 bytes
25const MAX_BYTE_LEN: usize = 1_048_487;
26
27impl Serializer for FirestoreValueSerializer {
28    type Ok = Value;
29
30    type Error = Error;
31
32    type SerializeSeq = FirestoreArrayValueSerializer;
33
34    type SerializeTuple = FirestoreArrayValueSerializer;
35
36    type SerializeTupleStruct = FirestoreArrayValueSerializer;
37
38    type SerializeTupleVariant = NameMapValueSerializer<FirestoreArrayValueSerializer>;
39
40    type SerializeMap = FirestoreMapValueSerializer;
41
42    type SerializeStruct = FirestoreValueStructSerializer;
43
44    type SerializeStructVariant = NameMapValueSerializer<FirestoreMapValueSerializer>;
45
46    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
47        Ok(Value::from_bool(v))
48    }
49
50    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
51        self.serialize_i64(i64::from(v))
52    }
53
54    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
55        self.serialize_i64(i64::from(v))
56    }
57
58    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
59        self.serialize_i64(i64::from(v))
60    }
61
62    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
63        Ok(Value::from_i64(v))
64    }
65
66    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
67        self.serialize_i64(i64::from(v))
68    }
69
70    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
71        self.serialize_i64(i64::from(v))
72    }
73
74    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
75        self.serialize_i64(i64::from(v))
76    }
77
78    fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
79        Err(Error::from(ErrorCode::U64IsNotSupported))
80    }
81
82    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
83        self.serialize_f64(f64::from(v))
84    }
85
86    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
87        Ok(Value::from_f64(v))
88    }
89
90    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
91        self.serialize_str(&v.to_string())
92    }
93
94    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
95        if v.len() > MAX_BYTE_LEN {
96            return Err(Error::from(ErrorCode::MaximumByteLengthExceeded));
97        }
98        Ok(Value::from_string(v.to_string()))
99    }
100
101    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
102        // NOTE: unreachable. See: <https://serde.rs/impl-serialize.html#other-special-cases>
103        if v.len() > MAX_BYTE_LEN {
104            return Err(Error::from(ErrorCode::MaximumByteLengthExceeded));
105        }
106        Ok(Value::from_bytes(v.to_vec()))
107    }
108
109    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
110        Ok(Value::null())
111    }
112
113    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
114    where
115        T: ?Sized + Serialize,
116    {
117        value.serialize(self)
118    }
119
120    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
121        Ok(Value::null())
122    }
123
124    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
125        Ok(Value::null())
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        self.serialize_str(variant)
135    }
136
137    fn serialize_newtype_struct<T>(
138        self,
139        name: &'static str,
140        value: &T,
141    ) -> Result<Self::Ok, Self::Error>
142    where
143        T: ?Sized + Serialize,
144    {
145        if name == Reference::NAME {
146            value.serialize(FirestoreReferenceValueSerializer)
147        } else {
148            value.serialize(FirestoreValueSerializer)
149        }
150    }
151
152    fn serialize_newtype_variant<T>(
153        self,
154        _name: &'static str,
155        _variant_index: u32,
156        variant: &'static str,
157        value: &T,
158    ) -> Result<Self::Ok, Self::Error>
159    where
160        T: ?Sized + Serialize,
161    {
162        let mut map = self.serialize_map(Some(1))?;
163        serde::ser::SerializeMap::serialize_entry(&mut map, variant, value)?;
164        serde::ser::SerializeMap::end(map)
165    }
166
167    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
168        Ok(Self::SerializeSeq::new(len))
169    }
170
171    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
172        self.serialize_seq(Some(len))
173    }
174
175    fn serialize_tuple_struct(
176        self,
177        _name: &'static str,
178        len: usize,
179    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
180        self.serialize_tuple(len)
181    }
182
183    fn serialize_tuple_variant(
184        self,
185        _name: &'static str,
186        _variant_index: u32,
187        variant: &'static str,
188        len: usize,
189    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
190        Ok(Self::SerializeTupleVariant::new(
191            variant,
192            Self::SerializeSeq::new(Some(len)),
193        ))
194    }
195
196    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
197        Ok(Self::SerializeMap::new(len))
198    }
199
200    fn serialize_struct(
201        self,
202        name: &'static str,
203        len: usize,
204    ) -> Result<Self::SerializeStruct, Self::Error> {
205        Ok(Self::SerializeStruct::new(name, len))
206    }
207
208    fn serialize_struct_variant(
209        self,
210        _name: &'static str,
211        _variant_index: u32,
212        variant: &'static str,
213        len: usize,
214    ) -> Result<Self::SerializeStructVariant, Self::Error> {
215        Ok(Self::SerializeStructVariant::new(
216            variant,
217            Self::SerializeMap::new(Some(len)),
218        ))
219    }
220}
serde_firestore_value/ser/firestore_value_serializer.rs

serde_firestore_value/ser/
firestore_value_serializer.rs
