serde_fressian/value/
de.rs

1#![allow(non_camel_case_types, non_snake_case)]
2
3use std::collections::{BTreeMap};
4use std::fmt;
5
6use serde::de::{ self, Deserialize, SeqAccess, Visitor};
7
8use ordered_float::OrderedFloat;
9use serde_bytes::ByteBuf;
10
11// use error::{Error};
12use imp::codes;
13use value::Value;
14use inst::{INST};
15use uuid::{UUID};
16use uri::{URI};
17use regex::{REGEX};
18use sym::{SYM};
19use key::KEY;
20use typed_arrays::*;
21use set::{SET};
22
23macro_rules! impl_seed {
24    ($variant:ident : $T:ident) => {
25
26        struct $variant;
27
28        impl<'de> de::DeserializeSeed<'de> for $variant {
29            type Value = $T;
30
31            fn deserialize<D>(self, deserializer: D) -> Result<$T, D::Error>
32                where D: serde::Deserializer<'de>
33            {
34                $T::deserialize(deserializer)
35            }
36        }
37    }
38}
39
40impl_seed!(BYTES_SEED: ByteBuf);
41impl_seed!(SYM_SEED: SYM);
42impl_seed!(KEY_SEED: KEY);
43impl_seed!(INST_SEED: INST);
44impl_seed!(REGEX_SEED: REGEX);
45impl_seed!(UUID_SEED: UUID);
46impl_seed!(URI_SEED: URI);
47impl_seed!(INT_ARRAY_SEED: IntArray);
48impl_seed!(LONG_ARRAY_SEED: LongArray);
49impl_seed!(FLOAT_ARRAY_SEED: FloatArray);
50impl_seed!(DOUBLE_ARRAY_SEED: DoubleArray);
51impl_seed!(BOOLEAN_ARRAY_SEED: BooleanArray);
52
53
54impl<'de> Deserialize<'de> for Value {
55    #[inline]
56    fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
57        where D: serde::Deserializer<'de>
58    {
59        struct ValueVisitor;
60
61        impl<'de> de::DeserializeSeed<'de>  for ValueVisitor {
62            type Value = i8;
63
64            fn deserialize<D>(self, deserializer: D) -> Result<i8, D::Error>
65                where D: serde::Deserializer<'de>
66            {
67                struct CodeVisitor;
68
69                impl<'de> Visitor<'de> for CodeVisitor {
70                    type Value = i8;
71
72                    #[inline]
73                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
74                        formatter.write_str("code as i8")
75                    }
76
77                    fn visit_i8<E>(self, value: i8) -> Result<i8, E> {
78                        Ok(value)
79                    }
80                }
81
82                deserializer.deserialize_tuple_struct("CODE", 1, CodeVisitor)
83            }
84        }
85
86        impl<'de> Visitor<'de> for ValueVisitor {
87            type Value = Value;
88
89            #[inline]
90            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
91                formatter.write_str("any valid fressian value")
92            }
93
94            #[inline]
95            fn visit_seq<V>(self, mut seq: V) -> Result<Value, V::Error>
96            where
97                V: SeqAccess<'de>,
98            {
99                let code: Option<i8> = seq.next_element_seed(self)?;
100
101                if let Some(code) = code {
102                    match code as u8 {
103                        codes::NULL => {
104                            let _: Option<()> = seq.next_element()?;
105                            Ok(Value::NULL)
106                        },
107                        codes::TRUE | codes::FALSE => {
108                            let B: Option<bool> = seq.next_element()?;
109                            match B {
110                                Some(b) => Ok(Value::BOOL(b)),
111                                None => Err(de::Error::custom("expected BOOL"))
112                            }
113                        },
114                        0xFF | 0x00..=0x7f | codes::INT => {
115                            let val: Option<i64> = seq.next_element()?;
116                            match val {
117                                Some(i) => {
118                                    Ok(Value::INT(i))
119                                },
120                                None => Err(de::Error::custom("expected INT"))
121                            }
122                        }
123                        codes::FLOAT => {
124                            let val: Option<f32> = seq.next_element()?;
125                            match val {
126                                Some(f) => {
127                                    Ok(Value::FLOAT(OrderedFloat::from(f)))
128                                },
129                                None => Err(de::Error::custom("missing float"))
130                            }
131                        }
132                        codes::DOUBLE => {
133                            let val: Option<f64> = seq.next_element()?;
134                            match val {
135                                Some(f) => {
136                                    Ok(Value::DOUBLE(OrderedFloat::from(f)))
137                                },
138                                None => Err(de::Error::custom("missing double"))
139                            }
140                        }
141                        codes::UTF8
142                        |codes::STRING_PACKED_LENGTH_START..=codes::STRING_PACKED_LENGTH_END
143                        | codes::STRING => {
144                            let val: Option<String> = seq.next_element()?;
145                            match val {
146                                Some(s) => {
147                                    Ok(Value::STRING(s))
148                                },
149                                None => Err(de::Error::custom("missing double"))
150                            }
151                        }
152                        codes::BYTES_PACKED_LENGTH_START..=0xD8
153                        | codes::BYTES => {
154                            let val: Option<ByteBuf> = seq.next_element_seed(BYTES_SEED)?;
155                            match val {
156                                Some(bb) => {
157                                    Ok(Value::BYTES(bb))
158                                },
159                                None => Err(de::Error::custom("missing BYTES"))
160                            }
161                        }
162                        codes::LIST_PACKED_LENGTH_START..=235
163                        | codes::LIST
164                        | codes::BEGIN_OPEN_LIST => {
165                            let val: Option<Vec<Value>> = seq.next_element()?;
166                            match val {
167                                Some(v) => {
168                                    Ok(Value::LIST(v))
169                                },
170                                None => Err(de::Error::custom("missing LIST"))
171                            }
172                        }
173                        codes::SET => {
174                            let val: Option<SET<Value>> = seq.next_element()?;
175                            match val {
176                                Some(v) => {
177                                    Ok(Value::SET(v))
178                                },
179                                None => Err(de::Error::custom("missing map"))
180                            }
181                        }
182                        codes::MAP => {
183                            let val: Option<BTreeMap<Value,Value>> = seq.next_element()?;
184                            match val {
185                                Some(m) => {
186                                    Ok(Value::MAP(m))
187                                },
188                                None => Err(de::Error::custom("missing map"))
189                            }
190                        }
191                        codes::KEY => {
192                            let val: Option<KEY> = seq.next_element_seed(KEY_SEED)?;
193                            match val {
194                                Some(key) => {
195                                    Ok(Value::KEY(key))
196                                },
197                                None => Err(de::Error::custom("missing KEY"))
198                            }
199                        }
200                        codes::SYM => {
201                            let val: Option<SYM> = seq.next_element_seed(SYM_SEED)?;
202                            match val {
203                                Some(sym) => {
204                                    Ok(Value::SYM(sym))
205                                },
206                                None => Err(de::Error::custom("missing SYM"))
207                            }
208                        }
209                        codes::INST => {
210                            let val: Option<INST> = seq.next_element_seed(INST_SEED)?;
211                            match val {
212                                Some(inst) => {
213                                    Ok(Value::INST(inst))
214                                },
215                                None => Err(de::Error::custom("missing INST"))
216                            }
217                        }
218                        codes::REGEX => {
219                            let val: Option<REGEX> = seq.next_element_seed(REGEX_SEED)?;
220                            match val {
221                                Some(regex) => {
222                                    Ok(Value::REGEX(regex))
223                                },
224                                None => Err(de::Error::custom("missing REGEX"))
225                            }
226                        }
227                        codes::UUID => {
228                            let val: Option<UUID> = seq.next_element_seed(UUID_SEED)?;
229                            match val {
230                                Some(u) => {
231                                    Ok(Value::UUID(u))
232                                },
233                                None => Err(de::Error::custom("missing UUID"))
234                            }
235                        }
236                        codes::URI => {
237                            let val: Option<URI> = seq.next_element_seed(URI_SEED)?;
238                            match val {
239                                Some(u) => {
240                                    Ok(Value::URI(u))
241                                },
242                                None => Err(de::Error::custom("missing URI"))
243                            }
244                        }
245                        codes::INT_ARRAY => {
246                            let val: Option<IntArray> = seq.next_element_seed(INT_ARRAY_SEED)?;
247                            match val {
248                                Some(v) => {
249                                    Ok(Value::from(v))
250                                },
251                                None => Err(de::Error::custom("missing INT_ARRAY"))
252                            }
253                        }
254                        codes::LONG_ARRAY => {
255                            let val: Option<LongArray> = seq.next_element_seed(LONG_ARRAY_SEED)?;
256                            match val {
257                                Some(v) => {
258                                    Ok(Value::from(v))
259                                },
260                                None => Err(de::Error::custom("missing LONG_ARRAY"))
261                            }
262                        }
263                        codes::FLOAT_ARRAY => {
264                            let val: Option<FloatArray> = seq.next_element_seed(FLOAT_ARRAY_SEED)?;
265                            match val {
266                                Some(v) => {
267                                    Ok(Value::from(v))
268                                },
269                                None => Err(de::Error::custom("missing FLOAT_ARRAY"))
270                            }
271                        }
272                        codes::DOUBLE_ARRAY => {
273                            let val: Option<DoubleArray> = seq.next_element_seed(DOUBLE_ARRAY_SEED)?;
274                            match val {
275                                Some(v) => {
276                                    Ok(Value::from(v))
277                                },
278                                None => Err(de::Error::custom("missing DOUBLE_ARRAY"))
279                            }
280                        }
281                        codes::BOOLEAN_ARRAY => {
282                            let val: Option<BooleanArray> = seq.next_element_seed(BOOLEAN_ARRAY_SEED)?;
283                            match val {
284                                Some(v) => {
285                                    Ok(Value::from(v))
286                                },
287                                None => Err(de::Error::custom("missing BOOLEAN_ARRAY"))
288                            }
289                        }
290                        _ => Err(de::Error::custom(format!("Value UnmatchedCode:: {}", code as u8)))
291                    }
292                } else {
293                    Err(de::Error::custom("code == None"))
294                }
295            }
296        }
297        deserializer.deserialize_tuple(2, ValueVisitor)
298    }
299}
300
serde_fressian/value/de.rs

serde_fressian/value/
de.rs
