serde_cw_value/
ser.rs

1use serde::ser;
2use std::collections::BTreeMap;
3use std::error::Error;
4use std::fmt;
5
6use crate::Value;
7
8#[derive(Debug)]
9pub enum SerializerError {
10    Custom(String),
11}
12
13impl fmt::Display for SerializerError {
14    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
15        match *self {
16            SerializerError::Custom(ref s) => fmt.write_str(s),
17        }
18    }
19}
20
21impl Error for SerializerError {
22    fn description(&self) -> &str {
23        "Value serializer error"
24    }
25}
26
27impl ser::Error for SerializerError {
28    fn custom<T: fmt::Display>(msg: T) -> SerializerError {
29        SerializerError::Custom(msg.to_string())
30    }
31}
32
33impl ser::Serialize for Value {
34    fn serialize<S: ser::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
35        match *self {
36            Value::Bool(v) => s.serialize_bool(v),
37            Value::U8(v) => s.serialize_u8(v),
38            Value::U16(v) => s.serialize_u16(v),
39            Value::U32(v) => s.serialize_u32(v),
40            Value::U64(v) => s.serialize_u64(v),
41            Value::I8(v) => s.serialize_i8(v),
42            Value::I16(v) => s.serialize_i16(v),
43            Value::I32(v) => s.serialize_i32(v),
44            Value::I64(v) => s.serialize_i64(v),
45            Value::Char(v) => s.serialize_char(v),
46            Value::String(ref v) => s.serialize_str(v),
47            Value::Unit => s.serialize_unit(),
48            Value::Option(None) => s.serialize_none(),
49            Value::Option(Some(ref v)) => s.serialize_some(v),
50            Value::Newtype(ref v) => s.serialize_newtype_struct("", v),
51            Value::Seq(ref v) => v.serialize(s),
52            Value::Map(ref v) => v.serialize(s),
53            Value::Bytes(ref v) => s.serialize_bytes(v),
54        }
55    }
56}
57
58pub fn to_value<T: ser::Serialize>(value: T) -> Result<Value, SerializerError> {
59    value.serialize(Serializer)
60}
61
62struct Serializer;
63
64impl ser::Serializer for Serializer {
65    type Ok = Value;
66    type Error = SerializerError;
67    type SerializeSeq = SerializeSeq;
68    type SerializeTuple = SerializeTuple;
69    type SerializeTupleStruct = SerializeTupleStruct;
70    type SerializeTupleVariant = SerializeTupleVariant;
71    type SerializeMap = SerializeMap;
72    type SerializeStruct = SerializeStruct;
73    type SerializeStructVariant = SerializeStructVariant;
74
75    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
76        Ok(Value::Bool(v))
77    }
78
79    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
80        Ok(Value::I8(v))
81    }
82
83    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
84        Ok(Value::I16(v))
85    }
86
87    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
88        Ok(Value::I32(v))
89    }
90
91    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
92        Ok(Value::I64(v))
93    }
94
95    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
96        Ok(Value::U8(v))
97    }
98
99    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
100        Ok(Value::U16(v))
101    }
102
103    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
104        Ok(Value::U32(v))
105    }
106
107    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
108        Ok(Value::U64(v))
109    }
110
111    fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
112        Err(Self::Error::Custom(
113            "Floating point types are not supported by CosmWasm".to_owned(),
114        ))
115    }
116
117    fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
118        Err(Self::Error::Custom(
119            "Floating point types are not supported by CosmWasm".to_owned(),
120        ))
121    }
122
123    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
124        Ok(Value::Char(v))
125    }
126
127    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
128        Ok(Value::String(v.to_string()))
129    }
130
131    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
132        Ok(Value::Bytes(v.to_vec()))
133    }
134
135    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
136        Ok(Value::Option(None))
137    }
138
139    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
140    where
141        T: ser::Serialize,
142    {
143        value
144            .serialize(Serializer)
145            .map(|v| Value::Option(Some(Box::new(v))))
146    }
147
148    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
149        Ok(Value::Unit)
150    }
151
152    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
153        Ok(Value::Unit)
154    }
155
156    fn serialize_unit_variant(
157        self,
158        _name: &'static str,
159        _variant_index: u32,
160        variant: &'static str,
161    ) -> Result<Self::Ok, Self::Error> {
162        Ok(Value::String(variant.to_string()))
163    }
164
165    fn serialize_newtype_struct<T: ?Sized>(
166        self,
167        _name: &'static str,
168        value: &T,
169    ) -> Result<Self::Ok, Self::Error>
170    where
171        T: ser::Serialize,
172    {
173        value
174            .serialize(Serializer)
175            .map(|v| Value::Newtype(Box::new(v)))
176    }
177
178    fn serialize_newtype_variant<T: ?Sized>(
179        self,
180        _name: &'static str,
181        _variant_index: u32,
182        variant: &'static str,
183        value: &T,
184    ) -> Result<Self::Ok, Self::Error>
185    where
186        T: ser::Serialize,
187    {
188        value.serialize(Serializer).map(|v| {
189            let mut map = BTreeMap::new();
190            map.insert(Value::String(variant.to_string()), v);
191            Value::Map(map)
192        })
193    }
194
195    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
196        Ok(SerializeSeq(vec![]))
197    }
198
199    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
200        Ok(SerializeTuple(vec![]))
201    }
202
203    fn serialize_tuple_struct(
204        self,
205        _name: &'static str,
206        _len: usize,
207    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
208        Ok(SerializeTupleStruct(vec![]))
209    }
210
211    fn serialize_tuple_variant(
212        self,
213        _name: &'static str,
214        _variant_index: u32,
215        variant: &'static str,
216        len: usize,
217    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
218        Ok(SerializeTupleVariant(
219            Value::String(variant.to_string()),
220            Vec::with_capacity(len),
221        ))
222    }
223
224    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
225        Ok(SerializeMap {
226            map: BTreeMap::new(),
227            key: None,
228        })
229    }
230
231    fn serialize_struct(
232        self,
233        _name: &'static str,
234        _len: usize,
235    ) -> Result<Self::SerializeStruct, Self::Error> {
236        Ok(SerializeStruct(BTreeMap::new()))
237    }
238
239    fn serialize_struct_variant(
240        self,
241        _name: &'static str,
242        _variant_index: u32,
243        variant: &'static str,
244        _len: usize,
245    ) -> Result<Self::SerializeStructVariant, Self::Error> {
246        Ok(SerializeStructVariant(
247            Value::String(variant.to_string()),
248            BTreeMap::new(),
249        ))
250    }
251}
252
253struct SerializeSeq(Vec<Value>);
254
255impl ser::SerializeSeq for SerializeSeq {
256    type Ok = Value;
257    type Error = SerializerError;
258
259    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
260    where
261        T: ser::Serialize,
262    {
263        let value = value.serialize(Serializer)?;
264        self.0.push(value);
265        Ok(())
266    }
267
268    fn end(self) -> Result<Self::Ok, Self::Error> {
269        Ok(Value::Seq(self.0))
270    }
271}
272
273struct SerializeTuple(Vec<Value>);
274
275impl ser::SerializeTuple for SerializeTuple {
276    type Ok = Value;
277    type Error = SerializerError;
278
279    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
280    where
281        T: ser::Serialize,
282    {
283        let value = value.serialize(Serializer)?;
284        self.0.push(value);
285        Ok(())
286    }
287
288    fn end(self) -> Result<Self::Ok, Self::Error> {
289        Ok(Value::Seq(self.0))
290    }
291}
292
293struct SerializeTupleStruct(Vec<Value>);
294
295impl ser::SerializeTupleStruct for SerializeTupleStruct {
296    type Ok = Value;
297    type Error = SerializerError;
298
299    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
300    where
301        T: ser::Serialize,
302    {
303        let value = value.serialize(Serializer)?;
304        self.0.push(value);
305        Ok(())
306    }
307
308    fn end(self) -> Result<Self::Ok, Self::Error> {
309        Ok(Value::Seq(self.0))
310    }
311}
312
313struct SerializeTupleVariant(Value, Vec<Value>);
314
315impl ser::SerializeTupleVariant for SerializeTupleVariant {
316    type Ok = Value;
317    type Error = SerializerError;
318
319    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
320    where
321        T: ser::Serialize,
322    {
323        let value = value.serialize(Serializer)?;
324        self.1.push(value);
325        Ok(())
326    }
327
328    fn end(self) -> Result<Self::Ok, Self::Error> {
329        let mut map = BTreeMap::new();
330        map.insert(self.0, Value::Seq(self.1));
331        Ok(Value::Map(map))
332    }
333}
334
335struct SerializeMap {
336    map: BTreeMap<Value, Value>,
337    key: Option<Value>,
338}
339
340impl ser::SerializeMap for SerializeMap {
341    type Ok = Value;
342    type Error = SerializerError;
343
344    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
345    where
346        T: ser::Serialize,
347    {
348        let key = key.serialize(Serializer)?;
349        self.key = Some(key);
350        Ok(())
351    }
352
353    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
354    where
355        T: ser::Serialize,
356    {
357        let value = value.serialize(Serializer)?;
358        self.map.insert(self.key.take().unwrap(), value);
359        Ok(())
360    }
361
362    fn end(self) -> Result<Self::Ok, Self::Error> {
363        Ok(Value::Map(self.map))
364    }
365}
366
367struct SerializeStruct(BTreeMap<Value, Value>);
368
369impl ser::SerializeStruct for SerializeStruct {
370    type Ok = Value;
371    type Error = SerializerError;
372
373    fn serialize_field<T: ?Sized>(
374        &mut self,
375        key: &'static str,
376        value: &T,
377    ) -> Result<(), Self::Error>
378    where
379        T: ser::Serialize,
380    {
381        let key = Value::String(key.to_string());
382        let value = value.serialize(Serializer)?;
383        self.0.insert(key, value);
384        Ok(())
385    }
386
387    fn end(self) -> Result<Self::Ok, Self::Error> {
388        Ok(Value::Map(self.0))
389    }
390}
391
392struct SerializeStructVariant(Value, BTreeMap<Value, Value>);
393
394impl ser::SerializeStructVariant for SerializeStructVariant {
395    type Ok = Value;
396    type Error = SerializerError;
397
398    fn serialize_field<T: ?Sized>(
399        &mut self,
400        key: &'static str,
401        value: &T,
402    ) -> Result<(), Self::Error>
403    where
404        T: ser::Serialize,
405    {
406        let key = Value::String(key.to_string());
407        let value = value.serialize(Serializer)?;
408        self.1.insert(key, value);
409        Ok(())
410    }
411
412    fn end(self) -> Result<Self::Ok, Self::Error> {
413        let mut map = BTreeMap::new();
414        map.insert(self.0, Value::Map(self.1));
415        Ok(Value::Map(map))
416    }
417}
serde_cw_value/ser.rs

serde_cw_value/
ser.rs
