]>
Commit | Line | Data |
---|---|---|
7cac9316 XL |
1 | //! Definition of a TOML value |
2 | ||
041b39d2 XL |
3 | use std::collections::{BTreeMap, HashMap}; |
4 | use std::hash::Hash; | |
7cac9316 XL |
5 | use std::fmt; |
6 | use std::ops; | |
7 | use std::str::FromStr; | |
8 | use std::vec; | |
9 | ||
10 | use serde::ser; | |
11 | use serde::de; | |
041b39d2 | 12 | use serde::de::IntoDeserializer; |
7cac9316 XL |
13 | |
14 | pub use datetime::{Datetime, DatetimeParseError}; | |
0731742a | 15 | use datetime::{self, DatetimeFromString}; |
7cac9316 XL |
16 | |
17 | /// Representation of a TOML value. | |
18 | #[derive(PartialEq, Clone, Debug)] | |
19 | pub enum Value { | |
20 | /// Represents a TOML string | |
21 | String(String), | |
22 | /// Represents a TOML integer | |
23 | Integer(i64), | |
24 | /// Represents a TOML float | |
25 | Float(f64), | |
26 | /// Represents a TOML boolean | |
27 | Boolean(bool), | |
28 | /// Represents a TOML datetime | |
29 | Datetime(Datetime), | |
30 | /// Represents a TOML array | |
31 | Array(Array), | |
32 | /// Represents a TOML table | |
33 | Table(Table), | |
34 | } | |
35 | ||
36 | /// Type representing a TOML array, payload of the `Value::Array` variant | |
37 | pub type Array = Vec<Value>; | |
38 | ||
39 | /// Type representing a TOML table, payload of the `Value::Table` variant | |
40 | pub type Table = BTreeMap<String, Value>; | |
41 | ||
42 | impl Value { | |
43 | /// Convert a `T` into `toml::Value` which is an enum that can represent | |
44 | /// any valid TOML data. | |
45 | /// | |
46 | /// This conversion can fail if `T`'s implementation of `Serialize` decides to | |
47 | /// fail, or if `T` contains a map with non-string keys. | |
48 | pub fn try_from<T>(value: T) -> Result<Value, ::ser::Error> | |
49 | where T: ser::Serialize, | |
50 | { | |
51 | value.serialize(Serializer) | |
52 | } | |
53 | ||
54 | /// Interpret a `toml::Value` as an instance of type `T`. | |
55 | /// | |
56 | /// This conversion can fail if the structure of the `Value` does not match the | |
57 | /// structure expected by `T`, for example if `T` is a struct type but the | |
58 | /// `Value` contains something other than a TOML table. It can also fail if the | |
59 | /// structure is correct but `T`'s implementation of `Deserialize` decides that | |
60 | /// something is wrong with the data, for example required struct fields are | |
61 | /// missing from the TOML map or some number is too big to fit in the expected | |
62 | /// primitive type. | |
041b39d2 XL |
63 | pub fn try_into<'de, T>(self) -> Result<T, ::de::Error> |
64 | where T: de::Deserialize<'de>, | |
7cac9316 XL |
65 | { |
66 | de::Deserialize::deserialize(self) | |
67 | } | |
68 | ||
69 | /// Index into a TOML array or map. A string index can be used to access a | |
70 | /// value in a map, and a usize index can be used to access an element of an | |
71 | /// array. | |
72 | /// | |
73 | /// Returns `None` if the type of `self` does not match the type of the | |
74 | /// index, for example if the index is a string and `self` is an array or a | |
75 | /// number. Also returns `None` if the given key does not exist in the map | |
76 | /// or the given index is not within the bounds of the array. | |
77 | pub fn get<I: Index>(&self, index: I) -> Option<&Value> { | |
78 | index.index(self) | |
79 | } | |
80 | ||
81 | /// Mutably index into a TOML array or map. A string index can be used to | |
82 | /// access a value in a map, and a usize index can be used to access an | |
83 | /// element of an array. | |
84 | /// | |
85 | /// Returns `None` if the type of `self` does not match the type of the | |
86 | /// index, for example if the index is a string and `self` is an array or a | |
87 | /// number. Also returns `None` if the given key does not exist in the map | |
88 | /// or the given index is not within the bounds of the array. | |
89 | pub fn get_mut<I: Index>(&mut self, index: I) -> Option<&mut Value> { | |
90 | index.index_mut(self) | |
91 | } | |
92 | ||
93 | /// Extracts the integer value if it is an integer. | |
94 | pub fn as_integer(&self) -> Option<i64> { | |
95 | match *self { Value::Integer(i) => Some(i), _ => None } | |
96 | } | |
97 | ||
83c7162d | 98 | /// Tests whether this value is an integer. |
7cac9316 XL |
99 | pub fn is_integer(&self) -> bool { |
100 | self.as_integer().is_some() | |
101 | } | |
102 | ||
103 | /// Extracts the float value if it is a float. | |
104 | pub fn as_float(&self) -> Option<f64> { | |
105 | match *self { Value::Float(f) => Some(f), _ => None } | |
106 | } | |
107 | ||
83c7162d | 108 | /// Tests whether this value is a float. |
7cac9316 XL |
109 | pub fn is_float(&self) -> bool { |
110 | self.as_float().is_some() | |
111 | } | |
112 | ||
113 | /// Extracts the boolean value if it is a boolean. | |
114 | pub fn as_bool(&self) -> Option<bool> { | |
115 | match *self { Value::Boolean(b) => Some(b), _ => None } | |
116 | } | |
117 | ||
83c7162d | 118 | /// Tests whether this value is a boolean. |
7cac9316 XL |
119 | pub fn is_bool(&self) -> bool { |
120 | self.as_bool().is_some() | |
121 | } | |
122 | ||
123 | /// Extracts the string of this value if it is a string. | |
124 | pub fn as_str(&self) -> Option<&str> { | |
125 | match *self { Value::String(ref s) => Some(&**s), _ => None } | |
126 | } | |
127 | ||
83c7162d | 128 | /// Tests if this value is a string. |
7cac9316 XL |
129 | pub fn is_str(&self) -> bool { |
130 | self.as_str().is_some() | |
131 | } | |
132 | ||
133 | /// Extracts the datetime value if it is a datetime. | |
134 | /// | |
135 | /// Note that a parsed TOML value will only contain ISO 8601 dates. An | |
136 | /// example date is: | |
137 | /// | |
138 | /// ```notrust | |
139 | /// 1979-05-27T07:32:00Z | |
140 | /// ``` | |
141 | pub fn as_datetime(&self) -> Option<&Datetime> { | |
142 | match *self { Value::Datetime(ref s) => Some(s), _ => None } | |
143 | } | |
144 | ||
83c7162d | 145 | /// Tests whether this value is a datetime. |
7cac9316 XL |
146 | pub fn is_datetime(&self) -> bool { |
147 | self.as_datetime().is_some() | |
148 | } | |
149 | ||
150 | /// Extracts the array value if it is an array. | |
151 | pub fn as_array(&self) -> Option<&Vec<Value>> { | |
152 | match *self { Value::Array(ref s) => Some(s), _ => None } | |
153 | } | |
154 | ||
155 | /// Extracts the array value if it is an array. | |
156 | pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>> { | |
157 | match *self { Value::Array(ref mut s) => Some(s), _ => None } | |
158 | } | |
159 | ||
83c7162d | 160 | /// Tests whether this value is an array. |
7cac9316 XL |
161 | pub fn is_array(&self) -> bool { |
162 | self.as_array().is_some() | |
163 | } | |
164 | ||
165 | /// Extracts the table value if it is a table. | |
166 | pub fn as_table(&self) -> Option<&Table> { | |
167 | match *self { Value::Table(ref s) => Some(s), _ => None } | |
168 | } | |
169 | ||
170 | /// Extracts the table value if it is a table. | |
171 | pub fn as_table_mut(&mut self) -> Option<&mut Table> { | |
172 | match *self { Value::Table(ref mut s) => Some(s), _ => None } | |
173 | } | |
174 | ||
83c7162d | 175 | /// Tests whether this value is a table. |
7cac9316 XL |
176 | pub fn is_table(&self) -> bool { |
177 | self.as_table().is_some() | |
178 | } | |
179 | ||
180 | /// Tests whether this and another value have the same type. | |
181 | pub fn same_type(&self, other: &Value) -> bool { | |
182 | match (self, other) { | |
183 | (&Value::String(..), &Value::String(..)) | | |
184 | (&Value::Integer(..), &Value::Integer(..)) | | |
185 | (&Value::Float(..), &Value::Float(..)) | | |
186 | (&Value::Boolean(..), &Value::Boolean(..)) | | |
187 | (&Value::Datetime(..), &Value::Datetime(..)) | | |
188 | (&Value::Array(..), &Value::Array(..)) | | |
189 | (&Value::Table(..), &Value::Table(..)) => true, | |
190 | ||
191 | _ => false, | |
192 | } | |
193 | } | |
194 | ||
195 | /// Returns a human-readable representation of the type of this value. | |
196 | pub fn type_str(&self) -> &'static str { | |
197 | match *self { | |
198 | Value::String(..) => "string", | |
199 | Value::Integer(..) => "integer", | |
200 | Value::Float(..) => "float", | |
201 | Value::Boolean(..) => "boolean", | |
202 | Value::Datetime(..) => "datetime", | |
203 | Value::Array(..) => "array", | |
204 | Value::Table(..) => "table", | |
205 | } | |
206 | } | |
207 | } | |
208 | ||
209 | impl<I> ops::Index<I> for Value where I: Index { | |
210 | type Output = Value; | |
211 | ||
212 | fn index(&self, index: I) -> &Value { | |
213 | self.get(index).expect("index not found") | |
214 | } | |
215 | } | |
216 | ||
217 | impl<I> ops::IndexMut<I> for Value where I: Index { | |
218 | fn index_mut(&mut self, index: I) -> &mut Value { | |
219 | self.get_mut(index).expect("index not found") | |
220 | } | |
221 | } | |
222 | ||
041b39d2 XL |
223 | impl<'a> From<&'a str> for Value { |
224 | #[inline] | |
225 | fn from(val: &'a str) -> Value { | |
226 | Value::String(val.to_string()) | |
7cac9316 XL |
227 | } |
228 | } | |
229 | ||
041b39d2 XL |
230 | impl<V: Into<Value>> From<Vec<V>> for Value { |
231 | fn from(val: Vec<V>) -> Value { | |
232 | Value::Array(val.into_iter().map(|v| v.into()).collect()) | |
7cac9316 XL |
233 | } |
234 | } | |
235 | ||
041b39d2 XL |
236 | impl<S: Into<String>, V: Into<Value>> From<BTreeMap<S, V>> for Value { |
237 | fn from(val: BTreeMap<S, V>) -> Value { | |
238 | let table = val.into_iter() | |
239 | .map(|(s, v)| (s.into(), v.into())) | |
240 | .collect(); | |
7cac9316 | 241 | |
041b39d2 | 242 | Value::Table(table) |
7cac9316 XL |
243 | } |
244 | } | |
245 | ||
041b39d2 XL |
246 | impl<S: Into<String> + Hash + Eq, V: Into<Value>> From<HashMap<S, V>> for Value { |
247 | fn from(val: HashMap<S, V>) -> Value { | |
248 | let table = val.into_iter() | |
249 | .map(|(s, v)| (s.into(), v.into())) | |
250 | .collect(); | |
7cac9316 | 251 | |
041b39d2 | 252 | Value::Table(table) |
7cac9316 XL |
253 | } |
254 | } | |
255 | ||
041b39d2 XL |
256 | macro_rules! impl_into_value { |
257 | ($variant:ident : $T:ty) => { | |
258 | impl From<$T> for Value { | |
259 | #[inline] | |
260 | fn from(val: $T) -> Value { | |
261 | Value::$variant(val.into()) | |
262 | } | |
263 | } | |
7cac9316 XL |
264 | } |
265 | } | |
266 | ||
041b39d2 XL |
267 | impl_into_value!(String: String); |
268 | impl_into_value!(Integer: i64); | |
269 | impl_into_value!(Integer: i32); | |
270 | impl_into_value!(Integer: i8); | |
271 | impl_into_value!(Integer: u8); | |
272 | impl_into_value!(Integer: u32); | |
273 | impl_into_value!(Float: f64); | |
274 | impl_into_value!(Float: f32); | |
275 | impl_into_value!(Boolean: bool); | |
276 | impl_into_value!(Datetime: Datetime); | |
277 | ||
7cac9316 XL |
278 | /// Types that can be used to index a `toml::Value` |
279 | /// | |
280 | /// Currently this is implemented for `usize` to index arrays and `str` to index | |
281 | /// tables. | |
282 | /// | |
283 | /// This trait is sealed and not intended for implementation outside of the | |
284 | /// `toml` crate. | |
285 | pub trait Index: Sealed { | |
286 | #[doc(hidden)] | |
287 | fn index<'a>(&self, val: &'a Value) -> Option<&'a Value>; | |
288 | #[doc(hidden)] | |
289 | fn index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value>; | |
290 | } | |
291 | ||
292 | /// An implementation detail that should not be implemented, this will change in | |
293 | /// the future and break code otherwise. | |
294 | #[doc(hidden)] | |
295 | pub trait Sealed {} | |
296 | impl Sealed for usize {} | |
297 | impl Sealed for str {} | |
298 | impl Sealed for String {} | |
299 | impl<'a, T: Sealed + ?Sized> Sealed for &'a T {} | |
300 | ||
301 | impl Index for usize { | |
302 | fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> { | |
303 | match *val { | |
304 | Value::Array(ref a) => a.get(*self), | |
305 | _ => None, | |
306 | } | |
307 | } | |
308 | ||
309 | fn index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value> { | |
310 | match *val { | |
311 | Value::Array(ref mut a) => a.get_mut(*self), | |
312 | _ => None, | |
313 | } | |
314 | } | |
315 | } | |
316 | ||
317 | impl Index for str { | |
318 | fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> { | |
319 | match *val { | |
320 | Value::Table(ref a) => a.get(self), | |
321 | _ => None, | |
322 | } | |
323 | } | |
324 | ||
325 | fn index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value> { | |
326 | match *val { | |
327 | Value::Table(ref mut a) => a.get_mut(self), | |
328 | _ => None, | |
329 | } | |
330 | } | |
331 | } | |
332 | ||
333 | impl Index for String { | |
334 | fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> { | |
335 | self[..].index(val) | |
336 | } | |
337 | ||
338 | fn index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value> { | |
339 | self[..].index_mut(val) | |
340 | } | |
341 | } | |
342 | ||
343 | impl<'s, T: ?Sized> Index for &'s T where T: Index { | |
344 | fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> { | |
345 | (**self).index(val) | |
346 | } | |
347 | ||
348 | fn index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value> { | |
349 | (**self).index_mut(val) | |
350 | } | |
351 | } | |
352 | ||
353 | impl fmt::Display for Value { | |
354 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { | |
041b39d2 | 355 | ::ser::to_string(self).expect("Unable to represent value as string").fmt(f) |
7cac9316 XL |
356 | } |
357 | } | |
358 | ||
359 | impl FromStr for Value { | |
360 | type Err = ::de::Error; | |
361 | fn from_str(s: &str) -> Result<Value, Self::Err> { | |
362 | ::from_str(s) | |
363 | } | |
364 | } | |
365 | ||
366 | impl ser::Serialize for Value { | |
367 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
368 | where S: ser::Serializer | |
369 | { | |
370 | use serde::ser::SerializeMap; | |
371 | ||
372 | match *self { | |
373 | Value::String(ref s) => serializer.serialize_str(s), | |
374 | Value::Integer(i) => serializer.serialize_i64(i), | |
375 | Value::Float(f) => serializer.serialize_f64(f), | |
376 | Value::Boolean(b) => serializer.serialize_bool(b), | |
377 | Value::Datetime(ref s) => s.serialize(serializer), | |
378 | Value::Array(ref a) => a.serialize(serializer), | |
379 | Value::Table(ref t) => { | |
380 | let mut map = serializer.serialize_map(Some(t.len()))?; | |
381 | // Be sure to visit non-tables first (and also non | |
382 | // array-of-tables) as all keys must be emitted first. | |
383 | for (k, v) in t { | |
384 | if !v.is_table() && !v.is_array() || | |
385 | (v.as_array().map(|a| !a.iter().any(|v| v.is_table())).unwrap_or(false)) { | |
386 | map.serialize_entry(k, v)?; | |
387 | } | |
388 | } | |
389 | for (k, v) in t { | |
390 | if v.as_array().map(|a| a.iter().any(|v| v.is_table())).unwrap_or(false) { | |
391 | map.serialize_entry(k, v)?; | |
392 | } | |
393 | } | |
394 | for (k, v) in t { | |
395 | if v.is_table() { | |
396 | map.serialize_entry(k, v)?; | |
397 | } | |
398 | } | |
399 | map.end() | |
400 | } | |
401 | } | |
402 | } | |
403 | } | |
404 | ||
041b39d2 | 405 | impl<'de> de::Deserialize<'de> for Value { |
7cac9316 | 406 | fn deserialize<D>(deserializer: D) -> Result<Value, D::Error> |
041b39d2 | 407 | where D: de::Deserializer<'de>, |
7cac9316 XL |
408 | { |
409 | struct ValueVisitor; | |
410 | ||
041b39d2 | 411 | impl<'de> de::Visitor<'de> for ValueVisitor { |
7cac9316 XL |
412 | type Value = Value; |
413 | ||
414 | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
415 | formatter.write_str("any valid TOML value") | |
416 | } | |
417 | ||
418 | fn visit_bool<E>(self, value: bool) -> Result<Value, E> { | |
419 | Ok(Value::Boolean(value)) | |
420 | } | |
421 | ||
422 | fn visit_i64<E>(self, value: i64) -> Result<Value, E> { | |
423 | Ok(Value::Integer(value)) | |
424 | } | |
425 | ||
0731742a XL |
426 | fn visit_u64<E: de::Error>(self, value: u64) -> Result<Value, E> { |
427 | if value <= i64::max_value() as u64 { | |
428 | Ok(Value::Integer(value as i64)) | |
429 | } else { | |
430 | Err(de::Error::custom("u64 value was too large")) | |
431 | } | |
432 | } | |
433 | ||
434 | fn visit_u32<E>(self, value: u32) -> Result<Value, E> { | |
435 | Ok(Value::Integer(value.into())) | |
436 | } | |
437 | ||
438 | fn visit_i32<E>(self, value: i32) -> Result<Value, E> { | |
439 | Ok(Value::Integer(value.into())) | |
440 | } | |
441 | ||
7cac9316 XL |
442 | fn visit_f64<E>(self, value: f64) -> Result<Value, E> { |
443 | Ok(Value::Float(value)) | |
444 | } | |
445 | ||
446 | fn visit_str<E>(self, value: &str) -> Result<Value, E> { | |
447 | Ok(Value::String(value.into())) | |
448 | } | |
449 | ||
450 | fn visit_string<E>(self, value: String) -> Result<Value, E> { | |
451 | Ok(Value::String(value)) | |
452 | } | |
453 | ||
454 | fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error> | |
041b39d2 | 455 | where D: de::Deserializer<'de>, |
7cac9316 XL |
456 | { |
457 | de::Deserialize::deserialize(deserializer) | |
458 | } | |
459 | ||
041b39d2 XL |
460 | fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error> |
461 | where V: de::SeqAccess<'de>, | |
7cac9316 | 462 | { |
041b39d2 | 463 | let mut vec = Vec::new(); |
0731742a | 464 | while let Some(elem) = visitor.next_element()? { |
041b39d2 XL |
465 | vec.push(elem); |
466 | } | |
467 | Ok(Value::Array(vec)) | |
7cac9316 XL |
468 | } |
469 | ||
470 | fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error> | |
041b39d2 | 471 | where V: de::MapAccess<'de>, |
7cac9316 XL |
472 | { |
473 | let mut key = String::new(); | |
041b39d2 | 474 | let datetime = visitor.next_key_seed(DatetimeOrTable { |
7cac9316 XL |
475 | key: &mut key, |
476 | })?; | |
477 | match datetime { | |
478 | Some(true) => { | |
041b39d2 | 479 | let date: DatetimeFromString = visitor.next_value()?; |
7cac9316 XL |
480 | return Ok(Value::Datetime(date.value)) |
481 | } | |
482 | None => return Ok(Value::Table(BTreeMap::new())), | |
483 | Some(false) => {} | |
484 | } | |
485 | let mut map = BTreeMap::new(); | |
041b39d2 XL |
486 | map.insert(key, visitor.next_value()?); |
487 | while let Some(key) = visitor.next_key()? { | |
7cac9316 XL |
488 | if map.contains_key(&key) { |
489 | let msg = format!("duplicate key: `{}`", key); | |
490 | return Err(de::Error::custom(msg)) | |
491 | } | |
041b39d2 | 492 | map.insert(key, visitor.next_value()?); |
7cac9316 XL |
493 | } |
494 | Ok(Value::Table(map)) | |
495 | } | |
496 | } | |
497 | ||
041b39d2 | 498 | deserializer.deserialize_any(ValueVisitor) |
7cac9316 XL |
499 | } |
500 | } | |
501 | ||
041b39d2 | 502 | impl<'de> de::Deserializer<'de> for Value { |
7cac9316 XL |
503 | type Error = ::de::Error; |
504 | ||
041b39d2 XL |
505 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, ::de::Error> |
506 | where V: de::Visitor<'de>, | |
7cac9316 XL |
507 | { |
508 | match self { | |
509 | Value::Boolean(v) => visitor.visit_bool(v), | |
510 | Value::Integer(n) => visitor.visit_i64(n), | |
511 | Value::Float(n) => visitor.visit_f64(n), | |
512 | Value::String(v) => visitor.visit_string(v), | |
513 | Value::Datetime(v) => visitor.visit_string(v.to_string()), | |
514 | Value::Array(v) => { | |
515 | let len = v.len(); | |
516 | let mut deserializer = SeqDeserializer::new(v); | |
517 | let seq = visitor.visit_seq(&mut deserializer)?; | |
518 | let remaining = deserializer.iter.len(); | |
519 | if remaining == 0 { | |
520 | Ok(seq) | |
521 | } else { | |
522 | Err(de::Error::invalid_length(len, &"fewer elements in array")) | |
523 | } | |
524 | } | |
525 | Value::Table(v) => { | |
526 | let len = v.len(); | |
527 | let mut deserializer = MapDeserializer::new(v); | |
528 | let map = visitor.visit_map(&mut deserializer)?; | |
529 | let remaining = deserializer.iter.len(); | |
530 | if remaining == 0 { | |
531 | Ok(map) | |
532 | } else { | |
533 | Err(de::Error::invalid_length(len, &"fewer elements in map")) | |
534 | } | |
535 | } | |
536 | } | |
537 | } | |
538 | ||
041b39d2 XL |
539 | #[inline] |
540 | fn deserialize_enum<V>( | |
541 | self, | |
542 | _name: &str, | |
543 | _variants: &'static [&'static str], | |
544 | visitor: V, | |
545 | ) -> Result<V::Value, ::de::Error> | |
546 | where | |
547 | V: de::Visitor<'de>, | |
548 | { | |
549 | match self { | |
550 | Value::String(variant) => visitor.visit_enum(variant.into_deserializer()), | |
551 | _ => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"string only")), | |
552 | } | |
553 | } | |
554 | ||
7cac9316 XL |
555 | // `None` is interpreted as a missing field so be sure to implement `Some` |
556 | // as a present field. | |
557 | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, ::de::Error> | |
041b39d2 | 558 | where V: de::Visitor<'de>, |
7cac9316 XL |
559 | { |
560 | visitor.visit_some(self) | |
561 | } | |
562 | ||
3b2f2976 XL |
563 | fn deserialize_newtype_struct<V>( |
564 | self, | |
565 | _name: &'static str, | |
566 | visitor: V | |
567 | ) -> Result<V::Value, ::de::Error> | |
568 | where V: de::Visitor<'de> | |
569 | { | |
570 | visitor.visit_newtype_struct(self) | |
571 | } | |
572 | ||
041b39d2 | 573 | forward_to_deserialize_any! { |
7cac9316 | 574 | bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq |
041b39d2 | 575 | bytes byte_buf map unit_struct tuple_struct struct |
3b2f2976 | 576 | tuple ignored_any identifier |
7cac9316 XL |
577 | } |
578 | } | |
579 | ||
580 | struct SeqDeserializer { | |
581 | iter: vec::IntoIter<Value>, | |
582 | } | |
583 | ||
584 | impl SeqDeserializer { | |
585 | fn new(vec: Vec<Value>) -> Self { | |
586 | SeqDeserializer { | |
587 | iter: vec.into_iter(), | |
588 | } | |
589 | } | |
590 | } | |
591 | ||
041b39d2 | 592 | impl<'de> de::SeqAccess<'de> for SeqDeserializer { |
7cac9316 XL |
593 | type Error = ::de::Error; |
594 | ||
041b39d2 XL |
595 | fn next_element_seed<T>(&mut self, seed: T) |
596 | -> Result<Option<T::Value>, ::de::Error> | |
597 | where T: de::DeserializeSeed<'de>, | |
7cac9316 XL |
598 | { |
599 | match self.iter.next() { | |
600 | Some(value) => seed.deserialize(value).map(Some), | |
601 | None => Ok(None), | |
602 | } | |
603 | } | |
604 | ||
041b39d2 XL |
605 | fn size_hint(&self) -> Option<usize> { |
606 | match self.iter.size_hint() { | |
607 | (lower, Some(upper)) if lower == upper => Some(upper), | |
608 | _ => None, | |
609 | } | |
7cac9316 XL |
610 | } |
611 | } | |
612 | ||
613 | struct MapDeserializer { | |
614 | iter: <BTreeMap<String, Value> as IntoIterator>::IntoIter, | |
615 | value: Option<(String, Value)>, | |
616 | } | |
617 | ||
618 | impl MapDeserializer { | |
619 | fn new(map: BTreeMap<String, Value>) -> Self { | |
620 | MapDeserializer { | |
621 | iter: map.into_iter(), | |
622 | value: None, | |
623 | } | |
624 | } | |
625 | } | |
626 | ||
041b39d2 | 627 | impl<'de> de::MapAccess<'de> for MapDeserializer { |
7cac9316 XL |
628 | type Error = ::de::Error; |
629 | ||
041b39d2 XL |
630 | fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ::de::Error> |
631 | where T: de::DeserializeSeed<'de>, | |
7cac9316 XL |
632 | { |
633 | match self.iter.next() { | |
634 | Some((key, value)) => { | |
635 | self.value = Some((key.clone(), value)); | |
636 | seed.deserialize(Value::String(key)).map(Some) | |
637 | } | |
638 | None => Ok(None), | |
639 | } | |
640 | } | |
641 | ||
041b39d2 XL |
642 | fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, ::de::Error> |
643 | where T: de::DeserializeSeed<'de>, | |
7cac9316 XL |
644 | { |
645 | let (key, res) = match self.value.take() { | |
646 | Some((key, value)) => (key, seed.deserialize(value)), | |
647 | None => return Err(de::Error::custom("value is missing")), | |
648 | }; | |
649 | res.map_err(|mut error| { | |
650 | error.add_key_context(&key); | |
651 | error | |
652 | }) | |
653 | } | |
654 | ||
041b39d2 XL |
655 | fn size_hint(&self) -> Option<usize> { |
656 | match self.iter.size_hint() { | |
657 | (lower, Some(upper)) if lower == upper => Some(upper), | |
658 | _ => None, | |
659 | } | |
660 | } | |
661 | } | |
662 | ||
663 | impl<'de> de::IntoDeserializer<'de, ::de::Error> for Value { | |
664 | type Deserializer = Self; | |
665 | ||
666 | fn into_deserializer(self) -> Self { | |
667 | self | |
7cac9316 XL |
668 | } |
669 | } | |
670 | ||
671 | struct Serializer; | |
672 | ||
673 | impl ser::Serializer for Serializer { | |
674 | type Ok = Value; | |
675 | type Error = ::ser::Error; | |
676 | ||
677 | type SerializeSeq = SerializeVec; | |
0731742a XL |
678 | type SerializeTuple = SerializeVec; |
679 | type SerializeTupleStruct = SerializeVec; | |
680 | type SerializeTupleVariant = SerializeVec; | |
7cac9316 XL |
681 | type SerializeMap = SerializeMap; |
682 | type SerializeStruct = SerializeMap; | |
683 | type SerializeStructVariant = ser::Impossible<Value, ::ser::Error>; | |
684 | ||
685 | fn serialize_bool(self, value: bool) -> Result<Value, ::ser::Error> { | |
686 | Ok(Value::Boolean(value)) | |
687 | } | |
688 | ||
689 | fn serialize_i8(self, value: i8) -> Result<Value, ::ser::Error> { | |
690 | self.serialize_i64(value.into()) | |
691 | } | |
692 | ||
693 | fn serialize_i16(self, value: i16) -> Result<Value, ::ser::Error> { | |
694 | self.serialize_i64(value.into()) | |
695 | } | |
696 | ||
697 | fn serialize_i32(self, value: i32) -> Result<Value, ::ser::Error> { | |
698 | self.serialize_i64(value.into()) | |
699 | } | |
700 | ||
701 | fn serialize_i64(self, value: i64) -> Result<Value, ::ser::Error> { | |
702 | Ok(Value::Integer(value.into())) | |
703 | } | |
704 | ||
705 | fn serialize_u8(self, value: u8) -> Result<Value, ::ser::Error> { | |
706 | self.serialize_i64(value.into()) | |
707 | } | |
708 | ||
709 | fn serialize_u16(self, value: u16) -> Result<Value, ::ser::Error> { | |
710 | self.serialize_i64(value.into()) | |
711 | } | |
712 | ||
713 | fn serialize_u32(self, value: u32) -> Result<Value, ::ser::Error> { | |
714 | self.serialize_i64(value.into()) | |
715 | } | |
716 | ||
717 | fn serialize_u64(self, value: u64) -> Result<Value, ::ser::Error> { | |
718 | if value <= i64::max_value() as u64 { | |
719 | self.serialize_i64(value as i64) | |
720 | } else { | |
721 | Err(ser::Error::custom("u64 value was too large")) | |
722 | } | |
723 | } | |
724 | ||
725 | fn serialize_f32(self, value: f32) -> Result<Value, ::ser::Error> { | |
726 | self.serialize_f64(value.into()) | |
727 | } | |
728 | ||
729 | fn serialize_f64(self, value: f64) -> Result<Value, ::ser::Error> { | |
730 | Ok(Value::Float(value)) | |
731 | } | |
732 | ||
733 | fn serialize_char(self, value: char) -> Result<Value, ::ser::Error> { | |
734 | let mut s = String::new(); | |
735 | s.push(value); | |
736 | self.serialize_str(&s) | |
737 | } | |
738 | ||
739 | fn serialize_str(self, value: &str) -> Result<Value, ::ser::Error> { | |
740 | Ok(Value::String(value.to_owned())) | |
741 | } | |
742 | ||
743 | fn serialize_bytes(self, value: &[u8]) -> Result<Value, ::ser::Error> { | |
744 | let vec = value.iter().map(|&b| Value::Integer(b.into())).collect(); | |
745 | Ok(Value::Array(vec)) | |
746 | } | |
747 | ||
748 | fn serialize_unit(self) -> Result<Value, ::ser::Error> { | |
749 | Err(::ser::Error::UnsupportedType) | |
750 | } | |
751 | ||
752 | fn serialize_unit_struct(self, _name: &'static str) | |
753 | -> Result<Value, ::ser::Error> { | |
754 | Err(::ser::Error::UnsupportedType) | |
755 | } | |
756 | ||
757 | fn serialize_unit_variant(self, | |
758 | _name: &'static str, | |
041b39d2 | 759 | _variant_index: u32, |
7cac9316 XL |
760 | _variant: &'static str) |
761 | -> Result<Value, ::ser::Error> { | |
041b39d2 | 762 | self.serialize_str(_variant) |
7cac9316 XL |
763 | } |
764 | ||
765 | fn serialize_newtype_struct<T: ?Sized>(self, | |
766 | _name: &'static str, | |
767 | value: &T) | |
768 | -> Result<Value, ::ser::Error> | |
769 | where T: ser::Serialize, | |
770 | { | |
771 | value.serialize(self) | |
772 | } | |
773 | ||
774 | fn serialize_newtype_variant<T: ?Sized>(self, | |
775 | _name: &'static str, | |
041b39d2 | 776 | _variant_index: u32, |
7cac9316 XL |
777 | _variant: &'static str, |
778 | _value: &T) | |
779 | -> Result<Value, ::ser::Error> | |
780 | where T: ser::Serialize, | |
781 | { | |
782 | Err(::ser::Error::UnsupportedType) | |
783 | } | |
784 | ||
785 | fn serialize_none(self) -> Result<Value, ::ser::Error> { | |
786 | Err(::ser::Error::UnsupportedNone) | |
787 | } | |
788 | ||
789 | fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Value, ::ser::Error> | |
790 | where T: ser::Serialize, | |
791 | { | |
792 | value.serialize(self) | |
793 | } | |
794 | ||
795 | fn serialize_seq(self, len: Option<usize>) | |
796 | -> Result<Self::SerializeSeq, ::ser::Error> | |
797 | { | |
798 | Ok(SerializeVec { | |
799 | vec: Vec::with_capacity(len.unwrap_or(0)) | |
800 | }) | |
801 | } | |
802 | ||
0731742a XL |
803 | fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, ::ser::Error> { |
804 | self.serialize_seq(Some(len)) | |
7cac9316 XL |
805 | } |
806 | ||
0731742a | 807 | fn serialize_tuple_struct(self, _name: &'static str, len: usize) |
7cac9316 | 808 | -> Result<Self::SerializeTupleStruct, ::ser::Error> { |
0731742a | 809 | self.serialize_seq(Some(len)) |
7cac9316 XL |
810 | } |
811 | ||
812 | fn serialize_tuple_variant(self, | |
813 | _name: &'static str, | |
041b39d2 | 814 | _variant_index: u32, |
7cac9316 | 815 | _variant: &'static str, |
0731742a | 816 | len: usize) |
7cac9316 XL |
817 | -> Result<Self::SerializeTupleVariant, ::ser::Error> |
818 | { | |
0731742a | 819 | self.serialize_seq(Some(len)) |
7cac9316 XL |
820 | } |
821 | ||
822 | fn serialize_map(self, _len: Option<usize>) | |
823 | -> Result<Self::SerializeMap, ::ser::Error> | |
824 | { | |
825 | Ok(SerializeMap { | |
826 | map: BTreeMap::new(), | |
827 | next_key: None, | |
828 | }) | |
829 | } | |
830 | ||
831 | fn serialize_struct(self, _name: &'static str, len: usize) | |
832 | -> Result<Self::SerializeStruct, ::ser::Error> { | |
833 | self.serialize_map(Some(len)) | |
834 | } | |
835 | ||
836 | fn serialize_struct_variant(self, | |
837 | _name: &'static str, | |
041b39d2 | 838 | _variant_index: u32, |
7cac9316 XL |
839 | _variant: &'static str, |
840 | _len: usize) | |
841 | -> Result<Self::SerializeStructVariant, ::ser::Error> | |
842 | { | |
843 | Err(::ser::Error::UnsupportedType) | |
844 | } | |
845 | } | |
846 | ||
847 | struct SerializeVec { | |
848 | vec: Vec<Value>, | |
849 | } | |
850 | ||
851 | struct SerializeMap { | |
852 | map: BTreeMap<String, Value>, | |
853 | next_key: Option<String>, | |
854 | } | |
855 | ||
856 | impl ser::SerializeSeq for SerializeVec { | |
857 | type Ok = Value; | |
858 | type Error = ::ser::Error; | |
859 | ||
860 | fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> | |
861 | where T: ser::Serialize | |
862 | { | |
863 | self.vec.push(Value::try_from(value)?); | |
864 | Ok(()) | |
865 | } | |
866 | ||
867 | fn end(self) -> Result<Value, ::ser::Error> { | |
868 | Ok(Value::Array(self.vec)) | |
869 | } | |
870 | } | |
871 | ||
0731742a XL |
872 | impl ser::SerializeTuple for SerializeVec { |
873 | type Ok = Value; | |
874 | type Error = ::ser::Error; | |
875 | ||
876 | fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> | |
877 | where T: ser::Serialize | |
878 | { | |
879 | ser::SerializeSeq::serialize_element(self, value) | |
880 | } | |
881 | ||
882 | fn end(self) -> Result<Value, ::ser::Error> { | |
883 | ser::SerializeSeq::end(self) | |
884 | } | |
885 | } | |
886 | ||
887 | impl ser::SerializeTupleStruct for SerializeVec { | |
888 | type Ok = Value; | |
889 | type Error = ::ser::Error; | |
890 | ||
891 | fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> | |
892 | where T: ser::Serialize | |
893 | { | |
894 | ser::SerializeSeq::serialize_element(self, value) | |
895 | } | |
896 | ||
897 | fn end(self) -> Result<Value, ::ser::Error> { | |
898 | ser::SerializeSeq::end(self) | |
899 | } | |
900 | } | |
901 | ||
902 | impl ser::SerializeTupleVariant for SerializeVec { | |
903 | type Ok = Value; | |
904 | type Error = ::ser::Error; | |
905 | ||
906 | fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> | |
907 | where T: ser::Serialize | |
908 | { | |
909 | ser::SerializeSeq::serialize_element(self, value) | |
910 | } | |
911 | ||
912 | fn end(self) -> Result<Value, ::ser::Error> { | |
913 | ser::SerializeSeq::end(self) | |
914 | } | |
915 | } | |
916 | ||
7cac9316 XL |
917 | impl ser::SerializeMap for SerializeMap { |
918 | type Ok = Value; | |
919 | type Error = ::ser::Error; | |
920 | ||
921 | fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), ::ser::Error> | |
922 | where T: ser::Serialize | |
923 | { | |
924 | match Value::try_from(key)? { | |
925 | Value::String(s) => self.next_key = Some(s), | |
926 | _ => return Err(::ser::Error::KeyNotString), | |
927 | }; | |
928 | Ok(()) | |
929 | } | |
930 | ||
931 | fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> | |
932 | where T: ser::Serialize | |
933 | { | |
934 | let key = self.next_key.take(); | |
935 | let key = key.expect("serialize_value called before serialize_key"); | |
936 | match Value::try_from(value) { | |
937 | Ok(value) => { self.map.insert(key, value); } | |
938 | Err(::ser::Error::UnsupportedNone) => {} | |
939 | Err(e) => return Err(e), | |
940 | } | |
941 | Ok(()) | |
942 | } | |
943 | ||
944 | fn end(self) -> Result<Value, ::ser::Error> { | |
945 | Ok(Value::Table(self.map)) | |
946 | } | |
947 | } | |
948 | ||
949 | impl ser::SerializeStruct for SerializeMap { | |
950 | type Ok = Value; | |
951 | type Error = ::ser::Error; | |
952 | ||
953 | fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), ::ser::Error> | |
954 | where T: ser::Serialize | |
955 | { | |
0731742a | 956 | ser::SerializeMap::serialize_key(self, key)?; |
7cac9316 XL |
957 | ser::SerializeMap::serialize_value(self, value) |
958 | } | |
959 | ||
960 | fn end(self) -> Result<Value, ::ser::Error> { | |
961 | ser::SerializeMap::end(self) | |
962 | } | |
963 | } | |
964 | ||
965 | struct DatetimeOrTable<'a> { | |
966 | key: &'a mut String, | |
967 | } | |
968 | ||
041b39d2 | 969 | impl<'a, 'de> de::DeserializeSeed<'de> for DatetimeOrTable<'a> { |
7cac9316 XL |
970 | type Value = bool; |
971 | ||
972 | fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> | |
041b39d2 | 973 | where D: de::Deserializer<'de> |
7cac9316 | 974 | { |
041b39d2 | 975 | deserializer.deserialize_any(self) |
7cac9316 XL |
976 | } |
977 | } | |
978 | ||
041b39d2 | 979 | impl<'a, 'de> de::Visitor<'de> for DatetimeOrTable<'a> { |
7cac9316 XL |
980 | type Value = bool; |
981 | ||
982 | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
983 | formatter.write_str("a string key") | |
984 | } | |
985 | ||
986 | fn visit_str<E>(self, s: &str) -> Result<bool, E> | |
987 | where E: de::Error, | |
988 | { | |
0731742a | 989 | if s == datetime::FIELD { |
7cac9316 XL |
990 | Ok(true) |
991 | } else { | |
992 | self.key.push_str(s); | |
993 | Ok(false) | |
994 | } | |
995 | } | |
996 | ||
997 | fn visit_string<E>(self, s: String) -> Result<bool, E> | |
998 | where E: de::Error, | |
999 | { | |
0731742a | 1000 | if s == datetime::FIELD { |
7cac9316 XL |
1001 | Ok(true) |
1002 | } else { | |
1003 | *self.key = s; | |
1004 | Ok(false) | |
1005 | } | |
1006 | } | |
1007 | } |