liquid_core/model/object/
ser.rs

1use crate::model::KString;
2use serde::ser::Impossible;
3use serde::{self, Serialize};
4
5use crate::model::ser::{SerError, SerializeMap, SerializeStructVariant, SerializeTupleVariant};
6use crate::model::value::ser::ValueSerializer;
7use crate::model::Object;
8
9/// Convert a `T` into `liquid_core::model::Object`.
10pub fn to_object<T>(value: &T) -> Result<Object, crate::error::Error>
11where
12    T: Serialize,
13{
14    value.serialize(ObjectSerializer).map_err(|e| e.into())
15}
16
17struct ObjectSerializer;
18
19fn object_cannot_be_a_scalar() -> SerError {
20    SerError::new(crate::error::Error::with_msg("Object cannot be a scalar."))
21}
22
23fn object_cannot_be_an_array() -> SerError {
24    SerError::new(crate::error::Error::with_msg("Object cannot be an array."))
25}
26
27impl serde::Serializer for ObjectSerializer {
28    type Ok = Object;
29    type Error = SerError;
30
31    type SerializeSeq = Impossible<Object, SerError>;
32    type SerializeTuple = Impossible<Object, SerError>;
33    type SerializeTupleStruct = Impossible<Object, SerError>;
34    type SerializeTupleVariant = SerializeTupleVariant<Object>;
35    type SerializeMap = SerializeMap<Object>;
36    type SerializeStruct = SerializeMap<Object>;
37    type SerializeStructVariant = SerializeStructVariant<Object>;
38
39    #[inline]
40    fn serialize_bool(self, _value: bool) -> Result<Object, SerError> {
41        Err(object_cannot_be_a_scalar())
42    }
43
44    #[inline]
45    fn serialize_i8(self, _value: i8) -> Result<Object, SerError> {
46        Err(object_cannot_be_a_scalar())
47    }
48
49    #[inline]
50    fn serialize_i16(self, _value: i16) -> Result<Object, SerError> {
51        Err(object_cannot_be_a_scalar())
52    }
53
54    #[inline]
55    fn serialize_i32(self, _value: i32) -> Result<Object, SerError> {
56        Err(object_cannot_be_a_scalar())
57    }
58
59    fn serialize_i64(self, _value: i64) -> Result<Object, SerError> {
60        Err(object_cannot_be_a_scalar())
61    }
62
63    #[inline]
64    fn serialize_u8(self, _value: u8) -> Result<Object, SerError> {
65        Err(object_cannot_be_a_scalar())
66    }
67
68    #[inline]
69    fn serialize_u16(self, _value: u16) -> Result<Object, SerError> {
70        Err(object_cannot_be_a_scalar())
71    }
72
73    #[inline]
74    fn serialize_u32(self, _value: u32) -> Result<Object, SerError> {
75        Err(object_cannot_be_a_scalar())
76    }
77
78    #[inline]
79    fn serialize_u64(self, _value: u64) -> Result<Object, SerError> {
80        Err(object_cannot_be_a_scalar())
81    }
82
83    #[inline]
84    fn serialize_f32(self, _value: f32) -> Result<Object, SerError> {
85        Err(object_cannot_be_a_scalar())
86    }
87
88    #[inline]
89    fn serialize_f64(self, _value: f64) -> Result<Object, SerError> {
90        Err(object_cannot_be_a_scalar())
91    }
92
93    #[inline]
94    fn serialize_char(self, _value: char) -> Result<Object, SerError> {
95        Err(object_cannot_be_a_scalar())
96    }
97
98    #[inline]
99    fn serialize_str(self, _value: &str) -> Result<Object, SerError> {
100        Err(object_cannot_be_a_scalar())
101    }
102
103    fn serialize_bytes(self, _value: &[u8]) -> Result<Object, SerError> {
104        Err(object_cannot_be_a_scalar())
105    }
106
107    #[inline]
108    fn serialize_unit(self) -> Result<Object, SerError> {
109        Err(object_cannot_be_a_scalar())
110    }
111
112    #[inline]
113    fn serialize_unit_struct(self, _name: &'static str) -> Result<Object, SerError> {
114        Err(object_cannot_be_a_scalar())
115    }
116
117    #[inline]
118    fn serialize_unit_variant(
119        self,
120        _name: &'static str,
121        _variant_index: u32,
122        _variant: &'static str,
123    ) -> Result<Object, SerError> {
124        Err(object_cannot_be_a_scalar())
125    }
126
127    #[inline]
128    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Object, SerError>
129    where
130        T: Serialize + ?Sized,
131    {
132        value.serialize(ObjectSerializer)
133    }
134
135    fn serialize_newtype_variant<T>(
136        self,
137        _name: &'static str,
138        _variant_index: u32,
139        variant: &'static str,
140        value: &T,
141    ) -> Result<Object, SerError>
142    where
143        T: Serialize + ?Sized,
144    {
145        let mut values = Object::new();
146        values.insert(
147            KString::from_static(variant),
148            value.serialize(ValueSerializer)?,
149        );
150        Ok(values)
151    }
152
153    #[inline]
154    fn serialize_none(self) -> Result<Object, SerError> {
155        Err(object_cannot_be_a_scalar())
156    }
157
158    #[inline]
159    fn serialize_some<T>(self, value: &T) -> Result<Object, SerError>
160    where
161        T: Serialize + ?Sized,
162    {
163        value.serialize(ObjectSerializer)
164    }
165
166    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, SerError> {
167        Err(object_cannot_be_an_array())
168    }
169
170    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, SerError> {
171        Err(object_cannot_be_an_array())
172    }
173
174    fn serialize_tuple_struct(
175        self,
176        _name: &'static str,
177        _len: usize,
178    ) -> Result<Self::SerializeTupleStruct, SerError> {
179        Err(object_cannot_be_an_array())
180    }
181
182    fn serialize_tuple_variant(
183        self,
184        _name: &'static str,
185        _variant_index: u32,
186        variant: &'static str,
187        len: usize,
188    ) -> Result<Self::SerializeTupleVariant, SerError> {
189        Ok(SerializeTupleVariant {
190            name: KString::from_static(variant),
191            vec: Vec::with_capacity(len),
192            other: std::marker::PhantomData,
193        })
194    }
195
196    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, SerError> {
197        Ok(SerializeMap::Map {
198            map: Object::new(),
199            next_key: None,
200            other: std::marker::PhantomData,
201        })
202    }
203
204    fn serialize_struct(
205        self,
206        _name: &'static str,
207        len: usize,
208    ) -> Result<Self::SerializeStruct, SerError> {
209        self.serialize_map(Some(len))
210    }
211
212    fn serialize_struct_variant(
213        self,
214        _name: &'static str,
215        _variant_index: u32,
216        variant: &'static str,
217        _len: usize,
218    ) -> Result<Self::SerializeStructVariant, SerError> {
219        Ok(SerializeStructVariant {
220            name: KString::from_static(variant),
221            map: Object::new(),
222            other: std::marker::PhantomData,
223        })
224    }
225}
liquid_core/model/object/ser.rs

liquid_core/model/object/
ser.rs
