serde_ron/value/
ser.rs

1use serde::ser::{SerializeSeq, SerializeTuple, SerializeTupleStruct, SerializeTupleVariant, SerializeMap, SerializeStruct, SerializeStructVariant};
2use serde::Serialize;
3
4use std::collections::BTreeMap;
5
6use crate::Error;
7use super::{Primitive, Value, Data, Number};
8
9type Result<O> = std::result::Result<O, Error>;
10
11pub struct Serializer;
12
13impl serde::Serializer for Serializer {
14    type Ok = Value;
15    type Error = Error;
16    type SerializeSeq = Sequence;
17    type SerializeTuple = Tuple;
18    type SerializeTupleStruct = TupleStruct;
19    type SerializeTupleVariant = TupleVariant;
20    type SerializeMap = Map;
21    type SerializeStruct = Struct;
22    type SerializeStructVariant = StructVariant;
23
24    fn serialize_bool(self, v: bool) -> Result<Value> {Ok(Value::Primitive(Primitive::bool(v)))}
25    fn serialize_i8(self, v: i8) -> Result<Value> {Ok(Value::Primitive(Primitive::Number(Number::i8(v))))}
26    fn serialize_i16(self, v: i16) -> Result<Value> {Ok(Value::Primitive(Primitive::Number(Number::i16(v))))}
27    fn serialize_i32(self, v: i32) -> Result<Value> {Ok(Value::Primitive(Primitive::Number(Number::i32(v))))}
28    fn serialize_i64(self, v: i64) -> Result<Value> {Ok(Value::Primitive(Primitive::Number(Number::i64(v))))}
29    fn serialize_u8(self, v: u8) -> Result<Value> {Ok(Value::Primitive(Primitive::Number(Number::u8(v))))}
30    fn serialize_u16(self, v: u16) -> Result<Value> {Ok(Value::Primitive(Primitive::Number(Number::u16(v))))}
31    fn serialize_u32(self, v: u32) -> Result<Value> {Ok(Value::Primitive(Primitive::Number(Number::u32(v))))}
32    fn serialize_u64(self, v: u64) -> Result<Value> {Ok(Value::Primitive(Primitive::Number(Number::u64(v))))}
33    fn serialize_f32(self, v: f32) -> Result<Value> {Ok(Value::Primitive(Primitive::Number(Number::f32(v))))}
34    fn serialize_f64(self, v: f64) -> Result<Value> {Ok(Value::Primitive(Primitive::Number(Number::f64(v))))}
35    fn serialize_char(self, v: char) -> Result<Value> {Ok(Value::Primitive(Primitive::char(v)))}
36    fn serialize_str(self, v: &str) -> Result<Value> {Ok(Value::Primitive(Primitive::String(v.to_string())))}
37    fn serialize_bytes(self, v: &[u8]) -> Result<Value> {Ok(Value::Primitive(Primitive::Bytes(v.to_vec())))}
38
39    fn serialize_none(self) -> Result<Value> {Ok(Value::None)}
40    fn serialize_some<T: Serialize + ?Sized>(self, value: &T) -> Result<Value> {Ok(Value::Some(Box::new(value.serialize(Serializer)?)))}
41    fn serialize_unit(self) -> Result<Value> {Ok(Value::Primitive(Primitive::Unit))}
42
43    fn serialize_unit_struct(self, name: &'static str) -> Result<Value> {
44        Ok(Value::Struct(name.to_string(), Data::Unit))
45    }
46    fn serialize_unit_variant(self, name: &'static str, _: u32, variant: &'static str) -> Result<Value> {
47        Ok(Value::Variant(name.to_string(), variant.to_string(), Data::Unit))
48    }
49
50    fn serialize_newtype_struct<T: Serialize + ?Sized>(self, name: &'static str, value: &T) -> Result<Value> {
51        Ok(Value::Struct(name.to_string(), Data::NewType(Box::new(value.serialize(Serializer)?))))
52    }
53    fn serialize_newtype_variant<T: Serialize + ?Sized>(
54        self, name: &'static str, _: u32, variant: &'static str, value: &T
55    ) -> Result<Value> {
56        Ok(Value::Variant(name.to_string(), variant.to_string(), Data::NewType(Box::new(value.serialize(Serializer)?))))
57    }
58
59    fn serialize_struct(self, name: &'static str, _: usize) -> Result<Struct> {
60        Ok(Struct(name.to_string(), BTreeMap::new()))
61    }
62    fn serialize_struct_variant(self, name: &'static str, _: u32, variant: &'static str, _: usize) -> Result<StructVariant> {
63        Ok(StructVariant(name.to_string(), variant.to_string(), BTreeMap::new()))
64    }
65
66    fn serialize_tuple_struct(self, name: &'static str, _: usize) -> Result<TupleStruct> {
67        Ok(TupleStruct(name.to_string(), Vec::new()))
68    }
69    fn serialize_tuple_variant(self, name: &'static str, _: u32, variant: &'static str, _: usize) -> Result<TupleVariant> {
70        Ok(TupleVariant(name.to_string(), variant.to_string(), Vec::new()))
71    }
72
73    fn serialize_tuple(self, _: usize) -> Result<Tuple> {Ok(Tuple(Vec::new()))}
74    fn serialize_seq(self, _: Option<usize>) -> Result<Sequence> {Ok(Sequence(Vec::new()))}
75    fn serialize_map(self, _: Option<usize>) -> Result<Map> {Ok(Map(None, BTreeMap::new()))}
76}
77
78pub struct Map(Option<Value>, BTreeMap<Value, Value>);
79impl SerializeMap for Map {
80    type Ok = Value;
81    type Error = Error;
82
83    fn serialize_key<T: Serialize + ?Sized>(&mut self, key: &T) -> Result<()> {
84        self.0 = Some(key.serialize(Serializer)?);
85        Ok(())
86    }
87    fn serialize_value<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
88        self.1.insert(self.0.take().unwrap(), value.serialize(Serializer)?);
89        Ok(())
90    }
91    fn end(self) -> Result<Value> {Ok(Value::Map(self.1))}
92}
93
94pub struct Sequence(Vec<Value>);
95impl SerializeSeq for Sequence {
96    type Ok = Value;
97    type Error = Error;
98
99    fn serialize_element<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
100        self.0.push(value.serialize(Serializer)?);
101        Ok(())
102    }
103    fn end(self) -> Result<Value> {Ok(Value::Vec(self.0))}
104}
105
106pub struct Tuple(Vec<Value>);
107impl SerializeTuple for Tuple {
108    type Ok = Value;
109    type Error = Error;
110
111    fn serialize_element<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
112        self.0.push(value.serialize(Serializer)?);
113        Ok(())
114    }
115    fn end(self) -> Result<Value> {Ok(Value::Tuple(self.0))}
116}
117
118pub struct TupleStruct(String, Vec<Value>);
119impl SerializeTupleStruct for TupleStruct {
120    type Ok = Value;
121    type Error = Error;
122
123    fn serialize_field<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
124        self.1.push(value.serialize(Serializer)?);
125        Ok(())
126    }
127    fn end(self) -> Result<Value> {Ok(Value::Struct(self.0, Data::Tuple(self.1)))}
128}
129
130pub struct TupleVariant(String, String, Vec<Value>);
131impl SerializeTupleVariant for TupleVariant {
132    type Ok = Value;
133    type Error = Error;
134
135    fn serialize_field<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
136        self.2.push(value.serialize(Serializer)?);
137        Ok(())
138    }
139    fn end(self) -> Result<Value> {Ok(Value::Variant(self.0, self.1, Data::Tuple(self.2)))}
140}
141
142pub struct Struct(String, BTreeMap<String, Value>);
143impl SerializeStruct for Struct {
144    type Ok = Value;
145    type Error = Error;
146
147    fn serialize_field<T: Serialize + ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()> {
148        self.1.insert(key.to_string(), value.serialize(Serializer)?);
149        Ok(())
150    }
151    fn end(self) -> Result<Value> {Ok(Value::Struct(self.0, Data::Struct(self.1)))}
152}
153
154pub struct StructVariant(String, String, BTreeMap<String, Value>);
155impl SerializeStructVariant for StructVariant {
156    type Ok = Value;
157    type Error = Error;
158
159    fn serialize_field<T: Serialize + ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()> {
160        self.2.insert(key.to_string(), value.serialize(Serializer)?);
161        Ok(())
162    }
163    fn end(self) -> Result<Value> {Ok(Value::Variant(self.0, self.1, Data::Struct(self.2)))}
164}
serde_ron/value/ser.rs

serde_ron/value/
ser.rs
