conjure_object/any/
ser.rs

1// Copyright 2020 Palantir Technologies, Inc.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14use crate::any::{Any, Error, Inner};
15use ordered_float::OrderedFloat;
16use serde::ser::{
17    Error as _, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant,
18    SerializeTuple, SerializeTupleStruct, SerializeTupleVariant,
19};
20use serde::{Serialize, Serializer};
21use std::collections::BTreeMap;
22use std::f64;
23use std::fmt;
24
25impl Serialize for Any {
26    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
27    where
28        S: Serializer,
29    {
30        match &self.0 {
31            Inner::Null => serializer.serialize_unit(),
32            Inner::Bool(v) => serializer.serialize_bool(*v),
33            Inner::I8(v) => serializer.serialize_i8(*v),
34            Inner::I16(v) => serializer.serialize_i16(*v),
35            Inner::I32(v) => serializer.serialize_i32(*v),
36            Inner::I64(v) => serializer.serialize_i64(*v),
37            Inner::I128(v) => serializer.serialize_i128(*v),
38            Inner::U8(v) => serializer.serialize_u8(*v),
39            Inner::U16(v) => serializer.serialize_u16(*v),
40            Inner::U32(v) => serializer.serialize_u32(*v),
41            Inner::U64(v) => serializer.serialize_u64(*v),
42            Inner::U128(v) => serializer.serialize_u128(*v),
43            Inner::F32(v) => serializer.serialize_f32(v.0),
44            Inner::F64(v) => serializer.serialize_f64(v.0),
45            Inner::Char(v) => serializer.serialize_char(*v),
46            Inner::String(v) => serializer.serialize_str(v),
47            Inner::Bytes(v) => serializer.serialize_bytes(v),
48            Inner::Seq(v) => v.serialize(serializer),
49            Inner::Map(v) => v.serialize(serializer),
50        }
51    }
52}
53
54pub(crate) struct AnySerializer;
55
56impl Serializer for AnySerializer {
57    type Ok = Any;
58    type Error = Error;
59    type SerializeSeq = SeqSerializer;
60    type SerializeTuple = SeqSerializer;
61    type SerializeTupleStruct = SeqSerializer;
62    type SerializeTupleVariant = TupleVariantSerializer;
63    type SerializeMap = MapSerializer;
64    type SerializeStruct = MapSerializer;
65    type SerializeStructVariant = StructVariantSerializer;
66
67    #[inline]
68    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
69        Ok(Any(Inner::Bool(v)))
70    }
71
72    #[inline]
73    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
74        Ok(Any(Inner::I8(v)))
75    }
76
77    #[inline]
78    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
79        Ok(Any(Inner::I16(v)))
80    }
81
82    #[inline]
83    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
84        Ok(Any(Inner::I32(v)))
85    }
86
87    #[inline]
88    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
89        Ok(Any(Inner::I64(v)))
90    }
91
92    #[inline]
93    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
94        Ok(Any(Inner::I128(v)))
95    }
96
97    #[inline]
98    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
99        Ok(Any(Inner::U8(v)))
100    }
101
102    #[inline]
103    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
104        Ok(Any(Inner::U16(v)))
105    }
106
107    #[inline]
108    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
109        Ok(Any(Inner::U32(v)))
110    }
111
112    #[inline]
113    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
114        Ok(Any(Inner::U64(v)))
115    }
116
117    #[inline]
118    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
119        Ok(Any(Inner::U128(v)))
120    }
121
122    #[inline]
123    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
124        Ok(Any(Inner::F32(OrderedFloat(v))))
125    }
126
127    #[inline]
128    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
129        Ok(Any(Inner::F64(OrderedFloat(v))))
130    }
131
132    #[inline]
133    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
134        Ok(Any(Inner::String(v.to_string())))
135    }
136
137    #[inline]
138    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
139        Ok(Any(Inner::String(v.to_string())))
140    }
141
142    #[inline]
143    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
144        Ok(Any(Inner::Bytes(v.to_vec())))
145    }
146
147    #[inline]
148    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
149        Ok(Any(Inner::Null))
150    }
151
152    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
153    where
154        T: ?Sized + Serialize,
155    {
156        value.serialize(self)
157    }
158
159    #[inline]
160    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
161        Ok(Any(Inner::Null))
162    }
163
164    #[inline]
165    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
166        self.serialize_unit()
167    }
168
169    #[inline]
170    fn serialize_unit_variant(
171        self,
172        _: &'static str,
173        _: u32,
174        variant: &'static str,
175    ) -> Result<Self::Ok, Self::Error> {
176        self.serialize_str(variant)
177    }
178
179    fn serialize_newtype_struct<T>(
180        self,
181        _: &'static str,
182        value: &T,
183    ) -> Result<Self::Ok, Self::Error>
184    where
185        T: ?Sized + Serialize,
186    {
187        value.serialize(self)
188    }
189
190    fn serialize_newtype_variant<T>(
191        self,
192        _: &'static str,
193        _: u32,
194        variant: &'static str,
195        value: &T,
196    ) -> Result<Self::Ok, Self::Error>
197    where
198        T: ?Sized + Serialize,
199    {
200        let mut map = BTreeMap::new();
201        let value = value.serialize(self)?;
202        map.insert(Any(Inner::String(variant.to_string())), value);
203        Ok(Any(Inner::Map(map)))
204    }
205
206    #[inline]
207    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
208        Ok(SeqSerializer(Vec::with_capacity(len.unwrap_or(0))))
209    }
210
211    #[inline]
212    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
213        self.serialize_seq(Some(len))
214    }
215
216    #[inline]
217    fn serialize_tuple_struct(
218        self,
219        _: &'static str,
220        len: usize,
221    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
222        self.serialize_seq(Some(len))
223    }
224
225    #[inline]
226    fn serialize_tuple_variant(
227        self,
228        _: &'static str,
229        _: u32,
230        variant: &'static str,
231        len: usize,
232    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
233        Ok(TupleVariantSerializer {
234            variant,
235            vec: Vec::with_capacity(len),
236        })
237    }
238
239    #[inline]
240    fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
241        Ok(MapSerializer {
242            map: BTreeMap::new(),
243            key: None,
244        })
245    }
246
247    #[inline]
248    fn serialize_struct(
249        self,
250        _: &'static str,
251        len: usize,
252    ) -> Result<Self::SerializeStruct, Self::Error> {
253        self.serialize_map(Some(len))
254    }
255
256    #[inline]
257    fn serialize_struct_variant(
258        self,
259        _: &'static str,
260        _: u32,
261        variant: &'static str,
262        _: usize,
263    ) -> Result<Self::SerializeStructVariant, Self::Error> {
264        Ok(StructVariantSerializer {
265            variant,
266            map: BTreeMap::new(),
267        })
268    }
269
270    fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
271    where
272        T: ?Sized + fmt::Display,
273    {
274        Ok(Any(Inner::String(value.to_string())))
275    }
276}
277
278pub(crate) struct SeqSerializer(Vec<Any>);
279
280impl SerializeSeq for SeqSerializer {
281    type Ok = Any;
282    type Error = Error;
283
284    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
285    where
286        T: ?Sized + Serialize,
287    {
288        let value = Any::new(value)?;
289        self.0.push(value);
290        Ok(())
291    }
292
293    #[inline]
294    fn end(self) -> Result<Self::Ok, Self::Error> {
295        Ok(Any(Inner::Seq(self.0)))
296    }
297}
298
299impl SerializeTuple for SeqSerializer {
300    type Ok = Any;
301    type Error = Error;
302
303    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
304    where
305        T: ?Sized + Serialize,
306    {
307        SerializeSeq::serialize_element(self, value)
308    }
309
310    #[inline]
311    fn end(self) -> Result<Self::Ok, Self::Error> {
312        SerializeSeq::end(self)
313    }
314}
315
316impl SerializeTupleStruct for SeqSerializer {
317    type Ok = Any;
318    type Error = Error;
319
320    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
321    where
322        T: ?Sized + Serialize,
323    {
324        SerializeSeq::serialize_element(self, value)
325    }
326
327    #[inline]
328    fn end(self) -> Result<Self::Ok, Self::Error> {
329        SerializeSeq::end(self)
330    }
331}
332
333pub(crate) struct TupleVariantSerializer {
334    variant: &'static str,
335    vec: Vec<Any>,
336}
337
338impl SerializeTupleVariant for TupleVariantSerializer {
339    type Ok = Any;
340    type Error = Error;
341
342    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
343    where
344        T: ?Sized + Serialize,
345    {
346        let value = Any::new(value)?;
347        self.vec.push(value);
348        Ok(())
349    }
350
351    #[inline]
352    fn end(self) -> Result<Self::Ok, Self::Error> {
353        let mut out = BTreeMap::new();
354        out.insert(
355            Any(Inner::String(self.variant.to_string())),
356            Any(Inner::Seq(self.vec)),
357        );
358        Ok(Any(Inner::Map(out)))
359    }
360}
361
362pub(crate) struct MapSerializer {
363    map: BTreeMap<Any, Any>,
364    key: Option<Any>,
365}
366
367impl SerializeMap for MapSerializer {
368    type Ok = Any;
369    type Error = Error;
370
371    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
372    where
373        T: ?Sized + Serialize,
374    {
375        let key = key.serialize(AnySerializer)?;
376        self.key = Some(key);
377        Ok(())
378    }
379
380    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
381    where
382        T: ?Sized + Serialize,
383    {
384        let key = match self.key.take() {
385            Some(key) => key,
386            None => return Err(Error::custom("key missing")),
387        };
388
389        let value = value.serialize(AnySerializer)?;
390        self.map.insert(key, value);
391
392        Ok(())
393    }
394
395    fn end(self) -> Result<Self::Ok, Self::Error> {
396        Ok(Any(Inner::Map(self.map)))
397    }
398}
399
400impl SerializeStruct for MapSerializer {
401    type Ok = Any;
402    type Error = Error;
403
404    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
405    where
406        T: ?Sized + Serialize,
407    {
408        SerializeMap::serialize_entry(self, key, value)
409    }
410
411    fn end(self) -> Result<Self::Ok, Self::Error> {
412        SerializeMap::end(self)
413    }
414}
415
416pub(crate) struct StructVariantSerializer {
417    variant: &'static str,
418    map: BTreeMap<Any, Any>,
419}
420
421impl SerializeStructVariant for StructVariantSerializer {
422    type Ok = Any;
423    type Error = Error;
424
425    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
426    where
427        T: ?Sized + Serialize,
428    {
429        let key = key.serialize(AnySerializer)?;
430        let value = value.serialize(AnySerializer)?;
431        self.map.insert(key, value);
432        Ok(())
433    }
434
435    fn end(self) -> Result<Self::Ok, Self::Error> {
436        let mut out = BTreeMap::new();
437        out.insert(
438            Any(Inner::String(self.variant.to_string())),
439            Any(Inner::Map(self.map)),
440        );
441        Ok(Any(Inner::Map(out)))
442    }
443}
conjure_object/any/ser.rs

conjure_object/any/
ser.rs
