serde_jce/
value.rs

1use std::cmp::Ordering;
2use std::collections::BTreeMap as Map;
3use std::fmt;
4
5use serde::de::{Error, MapAccess, SeqAccess, Visitor};
6use serde::ser::{SerializeMap, SerializeSeq, SerializeStruct};
7use serde::{Deserialize, Deserializer, Serialize, Serializer};
8
9pub enum Value {
10    Zero,
11    Int(i64),
12    Float(f32),
13    Double(f64),
14    String(String),
15    Bytes(Vec<u8>),
16    List(Vec<Value>),
17    Map(Map<Value, Value>),
18    Object(Map<u8, Value>),
19}
20
21////////////////////////////////////////////////////////////////////////////////
22// impl shortcut from
23
24impl From<i64> for Value {
25    fn from(v: i64) -> Self {
26        Value::Int(v)
27    }
28}
29
30impl From<f32> for Value {
31    fn from(v: f32) -> Self {
32        Value::Float(v)
33    }
34}
35
36impl From<f64> for Value {
37    fn from(v: f64) -> Self {
38        Value::Double(v)
39    }
40}
41
42impl From<&str> for Value {
43    fn from(v: &str) -> Self {
44        Value::String(v.to_owned())
45    }
46}
47
48impl From<String> for Value {
49    fn from(v: String) -> Self {
50        Value::String(v)
51    }
52}
53
54////////////////////////////////////////////////////////////////////////////////
55// impl shortcut getter
56
57macro_rules! value_getter {
58    ($func:ident, $enum:path, $arg:ty, $ret:ty) => {
59        pub fn $func(self: $arg) -> Option<$ret> {
60            match self {
61                $enum(v) => Some(v),
62                _ => None,
63            }
64        }
65    };
66}
67
68impl Value {
69    value_getter!(int, Value::Int, Self, i64);
70    value_getter!(int_ref, Value::Int, &Self, &i64);
71    value_getter!(int_mut, Value::Int, &mut Self, &mut i64);
72
73    value_getter!(float, Value::Float, Self, f32);
74    value_getter!(float_ref, Value::Float, &Self, &f32);
75    value_getter!(float_mut, Value::Float, &mut Self, &mut f32);
76
77    value_getter!(double, Value::Double, Self, f64);
78    value_getter!(double_ref, Value::Double, &Self, &f64);
79    value_getter!(double_mut, Value::Double, &mut Self, &mut f64);
80
81    value_getter!(string, Value::String, Self, String);
82    value_getter!(string_ref, Value::String, &Self, &String);
83    value_getter!(string_mut, Value::String, &mut Self, &mut String);
84
85    value_getter!(bytes, Value::Bytes, Self, Vec<u8>);
86    value_getter!(bytes_ref, Value::Bytes, &Self, &Vec<u8>);
87    value_getter!(bytes_mut, Value::Bytes, &mut Self, &mut Vec<u8>);
88
89    value_getter!(list, Value::List, Self, Vec<Value>);
90    value_getter!(list_ref, Value::List, &Self, &Vec<Value>);
91    value_getter!(list_mut, Value::List, &mut Self, &mut Vec<Value>);
92
93    value_getter!(map, Value::Map, Self, Map<Value,Value>);
94    value_getter!(map_ref, Value::Map, &Self, &Map<Value,Value>);
95    value_getter!(map_mut, Value::Map, &mut Self, &mut Map<Value,Value>);
96
97    value_getter!(obj, Value::Object, Self, Map<u8,Value>);
98    value_getter!(obj_ref, Value::Object, &Self, &Map<u8,Value>);
99    value_getter!(obj_mut, Value::Object, &mut Self, &mut Map<u8,Value>);
100}
101
102////////////////////////////////////////////////////////////////////////////////
103// impl fmt
104
105impl fmt::Debug for Value {
106    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
107        match self {
108            Value::Zero => f.write_str("Zero"),
109            Value::Int(v) => v.fmt(f),
110            Value::Float(v) => f.write_fmt(format_args!("{}f32", v)),
111            Value::Double(v) => f.write_fmt(format_args!("{}f64", v)),
112            Value::String(v) => v.fmt(f),
113            Value::Bytes(v) => f.write_fmt(format_args!("Bytes({})", &base64::encode(v))),
114            Value::List(v) => v.fmt(f),
115            Value::Map(v) => v.fmt(f),
116            Value::Object(v) => f.debug_tuple("Object").field(v).finish(),
117        }
118    }
119}
120
121////////////////////////////////////////////////////////////////////////////////
122// impl Ord for Map
123
124impl PartialEq for Value {
125    fn eq(&self, other: &Self) -> bool {
126        match self {
127            Value::Zero => match other {
128                Value::Zero => true,
129                _ => false,
130            },
131            Value::Int(lhs) => match other {
132                Value::Int(rhs) => lhs == rhs,
133                _ => false,
134            },
135            Value::Float(lhs) => match other {
136                Value::Float(rhs) => lhs.to_bits() == rhs.to_bits(),
137                _ => false,
138            },
139            Value::Double(lhs) => match other {
140                Value::Double(rhs) => lhs.to_bits() == rhs.to_bits(),
141                _ => false,
142            },
143            Value::String(lhs) => match other {
144                Value::String(rhs) => lhs == rhs,
145                _ => false,
146            },
147            Value::Bytes(lhs) => match other {
148                Value::Bytes(rhs) => lhs == rhs,
149                _ => false,
150            },
151            Value::List(lhs) => match other {
152                Value::List(rhs) => lhs == rhs,
153                _ => false,
154            },
155            Value::Map(lhs) => match other {
156                Value::Map(rhs) => lhs == rhs,
157                _ => false,
158            },
159            Value::Object(lhs) => match other {
160                Value::Object(rhs) => lhs == rhs,
161                _ => false,
162            },
163        }
164    }
165}
166
167impl Eq for Value {}
168
169impl PartialOrd for Value {
170    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
171        Some(Ord::cmp(self, other))
172    }
173}
174
175impl Ord for Value {
176    fn cmp(&self, other: &Self) -> Ordering {
177        match self {
178            Value::Zero => match other {
179                Value::Zero => Ordering::Equal,
180                _ => Ordering::Less,
181            },
182            Value::Int(lhs) => match other {
183                Value::Zero => Ordering::Greater,
184                Value::Int(rhs) => Ord::cmp(lhs, rhs),
185                _ => Ordering::Less,
186            },
187            Value::Float(lhs) => match other {
188                Value::Zero => Ordering::Greater,
189                Value::Int(_) => Ordering::Greater,
190                Value::Float(rhs) => Ord::cmp(&lhs.to_bits(), &rhs.to_bits()),
191                _ => Ordering::Less,
192            },
193            Value::Double(lhs) => match other {
194                Value::Zero => Ordering::Greater,
195                Value::Int(_) => Ordering::Greater,
196                Value::Float(_) => Ordering::Greater,
197                Value::Double(rhs) => Ord::cmp(&lhs.to_bits(), &rhs.to_bits()),
198                _ => Ordering::Less,
199            },
200            Value::String(lhs) => match other {
201                Value::Zero => Ordering::Greater,
202                Value::Int(_) => Ordering::Greater,
203                Value::Float(_) => Ordering::Greater,
204                Value::Double(_) => Ordering::Greater,
205                Value::String(rhs) => Ord::cmp(lhs, rhs),
206                _ => Ordering::Less,
207            },
208            Value::Bytes(lhs) => match other {
209                Value::Bytes(rhs) => Ord::cmp(lhs, rhs),
210                Value::List(_) => Ordering::Less,
211                Value::Map(_) => Ordering::Less,
212                Value::Object(_) => Ordering::Less,
213                _ => Ordering::Greater,
214            },
215            Value::List(lhs) => match other {
216                Value::List(rhs) => Ord::cmp(lhs, rhs),
217                Value::Map(_) => Ordering::Less,
218                Value::Object(_) => Ordering::Less,
219                _ => Ordering::Greater,
220            },
221            Value::Map(lhs) => match other {
222                Value::Map(rhs) => Ord::cmp(lhs, rhs),
223                Value::Object(_) => Ordering::Less,
224                _ => Ordering::Greater,
225            },
226            Value::Object(lhs) => match other {
227                Value::Object(rhs) => Ord::cmp(lhs, rhs),
228                _ => Ordering::Greater,
229            },
230        }
231    }
232}
233
234////////////////////////////////////////////////////////////////////////////////
235// impl Serialize
236
237impl Serialize for Value {
238    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
239    where
240        S: Serializer,
241    {
242        match self {
243            Value::Zero => serializer.serialize_none(),
244            Value::Int(v) => serializer.serialize_i64(*v),
245            Value::Float(v) => serializer.serialize_f32(*v),
246            Value::Double(v) => serializer.serialize_f64(*v),
247            Value::String(v) => serializer.serialize_str(v),
248            Value::Bytes(v) => serializer.serialize_bytes(v),
249            Value::List(v) => {
250                let mut seq = serializer.serialize_seq(Some(v.len()))?;
251                for e in v {
252                    seq.serialize_element(e)?;
253                }
254                seq.end()
255            }
256            Value::Map(v) => {
257                let mut seq = serializer.serialize_map(Some(v.len()))?;
258                for (k, v) in v {
259                    seq.serialize_entry(k, v)?;
260                }
261                seq.end()
262            }
263            Value::Object(v) => {
264                // stupid dirty trick, thanks to serde
265                const STR_TABLE: [&'static str; 256] = [
266                    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14",
267                    "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27",
268                    "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40",
269                    "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53",
270                    "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66",
271                    "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79",
272                    "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92",
273                    "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104",
274                    "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115",
275                    "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126",
276                    "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137",
277                    "138", "139", "140", "141", "142", "143", "144", "145", "146", "147", "148",
278                    "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159",
279                    "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170",
280                    "171", "172", "173", "174", "175", "176", "177", "178", "179", "180", "181",
281                    "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192",
282                    "193", "194", "195", "196", "197", "198", "199", "200", "201", "202", "203",
283                    "204", "205", "206", "207", "208", "209", "210", "211", "212", "213", "214",
284                    "215", "216", "217", "218", "219", "220", "221", "222", "223", "224", "225",
285                    "226", "227", "228", "229", "230", "231", "232", "233", "234", "235", "236",
286                    "237", "238", "239", "240", "241", "242", "243", "244", "245", "246", "247",
287                    "248", "249", "250", "251", "252", "253", "254", "255",
288                ];
289                let mut seq = serializer.serialize_struct("Value", v.len())?;
290                for (k, v) in v {
291                    seq.serialize_field(STR_TABLE[*k as usize], v)?;
292                }
293                seq.end()
294            }
295        }
296    }
297}
298
299////////////////////////////////////////////////////////////////////////////////
300// impl Deserialize
301
302struct ValueVisitor;
303
304impl<'de> Visitor<'de> for ValueVisitor {
305    type Value = Value;
306
307    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
308        formatter.write_str("a jce encoded object")
309    }
310
311    fn visit_none<E>(self) -> Result<Self::Value, E>
312    where
313        E: Error,
314    {
315        Ok(Value::Zero)
316    }
317
318    fn visit_i8<E>(self, value: i8) -> Result<Self::Value, E>
319    where
320        E: Error,
321    {
322        Ok(Value::Int(value as i64))
323    }
324
325    fn visit_i16<E>(self, value: i16) -> Result<Self::Value, E>
326    where
327        E: Error,
328    {
329        Ok(Value::Int(value as i64))
330    }
331
332    fn visit_i32<E>(self, value: i32) -> Result<Self::Value, E>
333    where
334        E: Error,
335    {
336        Ok(Value::Int(value as i64))
337    }
338
339    fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
340    where
341        E: Error,
342    {
343        Ok(Value::Int(value as i64))
344    }
345
346    fn visit_f32<E>(self, value: f32) -> Result<Self::Value, E>
347    where
348        E: Error,
349    {
350        Ok(Value::Float(value))
351    }
352
353    fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
354    where
355        E: Error,
356    {
357        Ok(Value::Double(value))
358    }
359
360    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
361    where
362        E: Error,
363    {
364        Ok(Value::String(value.to_owned()))
365    }
366
367    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
368    where
369        E: Error,
370    {
371        Ok(Value::Bytes(v.to_owned()))
372    }
373
374    fn visit_seq<A>(self, mut acc: A) -> Result<Self::Value, A::Error>
375    where
376        A: SeqAccess<'de>,
377    {
378        let mut vec: Vec<Value> = Vec::new();
379        while let Some(value) = acc.next_element()? {
380            vec.push(value);
381        }
382        Ok(Value::List(vec))
383    }
384
385    fn visit_map<A>(self, mut acc: A) -> Result<Self::Value, A::Error>
386    where
387        A: MapAccess<'de>,
388    {
389        if acc.size_hint().is_none() {
390            // Object
391            let mut map: Map<u8, Value> = Map::new();
392            while let Some((key, value)) = acc.next_entry()? {
393                map.insert(key, value);
394            }
395            Ok(Value::Object(map))
396        } else {
397            // Map
398            let mut map: Map<Value, Value> = Map::new();
399            while let Some((key, value)) = acc.next_entry()? {
400                map.insert(key, value);
401            }
402            Ok(Value::Map(map))
403        }
404    }
405}
406
407impl<'de> Deserialize<'de> for Value {
408    fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
409    where
410        D: Deserializer<'de>,
411    {
412        deserializer.deserialize_any(ValueVisitor)
413    }
414}
serde_jce/value.rs

serde_jce/
value.rs
