1 //! Definition of a TOML value 2 3 use std::collections::{BTreeMap, HashMap}; 4 use std::hash::Hash; 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; 12 use serde::de::IntoDeserializer; 13 14 pub use datetime::{Datetime, DatetimeParseError}; 15 use datetime::{self, DatetimeFromString}; 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. try_from<T>(value: T) -> Result<Value, ::ser::Error> where T: ser::Serialize,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. try_into<'de, T>(self) -> Result<T, ::de::Error> where T: de::Deserialize<'de>,63 pub fn try_into<'de, T>(self) -> Result<T, ::de::Error> 64 where T: de::Deserialize<'de>, 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. get<I: Index>(&self, index: I) -> Option<&Value>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. get_mut<I: Index>(&mut self, index: I) -> Option<&mut Value>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. as_integer(&self) -> Option<i64>94 pub fn as_integer(&self) -> Option<i64> { 95 match *self { Value::Integer(i) => Some(i), _ => None } 96 } 97 98 /// Tests whether this value is an integer. is_integer(&self) -> bool99 pub fn is_integer(&self) -> bool { 100 self.as_integer().is_some() 101 } 102 103 /// Extracts the float value if it is a float. as_float(&self) -> Option<f64>104 pub fn as_float(&self) -> Option<f64> { 105 match *self { Value::Float(f) => Some(f), _ => None } 106 } 107 108 /// Tests whether this value is a float. is_float(&self) -> bool109 pub fn is_float(&self) -> bool { 110 self.as_float().is_some() 111 } 112 113 /// Extracts the boolean value if it is a boolean. as_bool(&self) -> Option<bool>114 pub fn as_bool(&self) -> Option<bool> { 115 match *self { Value::Boolean(b) => Some(b), _ => None } 116 } 117 118 /// Tests whether this value is a boolean. is_bool(&self) -> bool119 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. as_str(&self) -> Option<&str>124 pub fn as_str(&self) -> Option<&str> { 125 match *self { Value::String(ref s) => Some(&**s), _ => None } 126 } 127 128 /// Tests if this value is a string. is_str(&self) -> bool129 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 /// ``` as_datetime(&self) -> Option<&Datetime>141 pub fn as_datetime(&self) -> Option<&Datetime> { 142 match *self { Value::Datetime(ref s) => Some(s), _ => None } 143 } 144 145 /// Tests whether this value is a datetime. is_datetime(&self) -> bool146 pub fn is_datetime(&self) -> bool { 147 self.as_datetime().is_some() 148 } 149 150 /// Extracts the array value if it is an array. as_array(&self) -> Option<&Vec<Value>>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. as_array_mut(&mut self) -> Option<&mut Vec<Value>>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 160 /// Tests whether this value is an array. is_array(&self) -> bool161 pub fn is_array(&self) -> bool { 162 self.as_array().is_some() 163 } 164 165 /// Extracts the table value if it is a table. as_table(&self) -> Option<&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. as_table_mut(&mut self) -> Option<&mut 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 175 /// Tests whether this value is a table. is_table(&self) -> bool176 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. same_type(&self, other: &Value) -> bool181 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. type_str(&self) -> &'static str196 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 index(&self, index: I) -> &Value212 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 { index_mut(&mut self, index: I) -> &mut Value218 fn index_mut(&mut self, index: I) -> &mut Value { 219 self.get_mut(index).expect("index not found") 220 } 221 } 222 223 impl<'a> From<&'a str> for Value { 224 #[inline] from(val: &'a str) -> Value225 fn from(val: &'a str) -> Value { 226 Value::String(val.to_string()) 227 } 228 } 229 230 impl<V: Into<Value>> From<Vec<V>> for Value { from(val: Vec<V>) -> Value231 fn from(val: Vec<V>) -> Value { 232 Value::Array(val.into_iter().map(|v| v.into()).collect()) 233 } 234 } 235 236 impl<S: Into<String>, V: Into<Value>> From<BTreeMap<S, V>> for Value { from(val: BTreeMap<S, V>) -> Value237 fn from(val: BTreeMap<S, V>) -> Value { 238 let table = val.into_iter() 239 .map(|(s, v)| (s.into(), v.into())) 240 .collect(); 241 242 Value::Table(table) 243 } 244 } 245 246 impl<S: Into<String> + Hash + Eq, V: Into<Value>> From<HashMap<S, V>> for Value { from(val: HashMap<S, V>) -> Value247 fn from(val: HashMap<S, V>) -> Value { 248 let table = val.into_iter() 249 .map(|(s, v)| (s.into(), v.into())) 250 .collect(); 251 252 Value::Table(table) 253 } 254 } 255 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 } 264 } 265 } 266 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 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)] index<'a>(&self, val: &'a Value) -> Option<&'a Value>287 fn index<'a>(&self, val: &'a Value) -> Option<&'a Value>; 288 #[doc(hidden)] index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value>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 { index<'a>(&self, val: &'a Value) -> Option<&'a Value>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 index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value>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 { index<'a>(&self, val: &'a Value) -> Option<&'a Value>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 index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value>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 { index<'a>(&self, val: &'a Value) -> Option<&'a Value>334 fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> { 335 self[..].index(val) 336 } 337 index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value>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 { index<'a>(&self, val: &'a Value) -> Option<&'a Value>344 fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> { 345 (**self).index(val) 346 } 347 index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value>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 { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result354 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 355 ::ser::to_string(self).expect("Unable to represent value as string").fmt(f) 356 } 357 } 358 359 impl FromStr for Value { 360 type Err = ::de::Error; from_str(s: &str) -> Result<Value, Self::Err>361 fn from_str(s: &str) -> Result<Value, Self::Err> { 362 ::from_str(s) 363 } 364 } 365 366 impl ser::Serialize for Value { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: ser::Serializer367 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 405 impl<'de> de::Deserialize<'de> for Value { deserialize<D>(deserializer: D) -> Result<Value, D::Error> where D: de::Deserializer<'de>,406 fn deserialize<D>(deserializer: D) -> Result<Value, D::Error> 407 where D: de::Deserializer<'de>, 408 { 409 struct ValueVisitor; 410 411 impl<'de> de::Visitor<'de> for ValueVisitor { 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 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 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> 455 where D: de::Deserializer<'de>, 456 { 457 de::Deserialize::deserialize(deserializer) 458 } 459 460 fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error> 461 where V: de::SeqAccess<'de>, 462 { 463 let mut vec = Vec::new(); 464 while let Some(elem) = visitor.next_element()? { 465 vec.push(elem); 466 } 467 Ok(Value::Array(vec)) 468 } 469 470 fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error> 471 where V: de::MapAccess<'de>, 472 { 473 let mut key = String::new(); 474 let datetime = visitor.next_key_seed(DatetimeOrTable { 475 key: &mut key, 476 })?; 477 match datetime { 478 Some(true) => { 479 let date: DatetimeFromString = visitor.next_value()?; 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(); 486 map.insert(key, visitor.next_value()?); 487 while let Some(key) = visitor.next_key()? { 488 if map.contains_key(&key) { 489 let msg = format!("duplicate key: `{}`", key); 490 return Err(de::Error::custom(msg)) 491 } 492 map.insert(key, visitor.next_value()?); 493 } 494 Ok(Value::Table(map)) 495 } 496 } 497 498 deserializer.deserialize_any(ValueVisitor) 499 } 500 } 501 502 impl<'de> de::Deserializer<'de> for Value { 503 type Error = ::de::Error; 504 deserialize_any<V>(self, visitor: V) -> Result<V::Value, ::de::Error> where V: de::Visitor<'de>,505 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, ::de::Error> 506 where V: de::Visitor<'de>, 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 539 #[inline] deserialize_enum<V>( self, _name: &str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, ::de::Error> where V: de::Visitor<'de>,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 555 // `None` is interpreted as a missing field so be sure to implement `Some` 556 // as a present field. deserialize_option<V>(self, visitor: V) -> Result<V::Value, ::de::Error> where V: de::Visitor<'de>,557 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, ::de::Error> 558 where V: de::Visitor<'de>, 559 { 560 visitor.visit_some(self) 561 } 562 deserialize_newtype_struct<V>( self, _name: &'static str, visitor: V ) -> Result<V::Value, ::de::Error> where V: de::Visitor<'de>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 573 forward_to_deserialize_any! { 574 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq 575 bytes byte_buf map unit_struct tuple_struct struct 576 tuple ignored_any identifier 577 } 578 } 579 580 struct SeqDeserializer { 581 iter: vec::IntoIter<Value>, 582 } 583 584 impl SeqDeserializer { new(vec: Vec<Value>) -> Self585 fn new(vec: Vec<Value>) -> Self { 586 SeqDeserializer { 587 iter: vec.into_iter(), 588 } 589 } 590 } 591 592 impl<'de> de::SeqAccess<'de> for SeqDeserializer { 593 type Error = ::de::Error; 594 next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ::de::Error> where T: de::DeserializeSeed<'de>,595 fn next_element_seed<T>(&mut self, seed: T) 596 -> Result<Option<T::Value>, ::de::Error> 597 where T: de::DeserializeSeed<'de>, 598 { 599 match self.iter.next() { 600 Some(value) => seed.deserialize(value).map(Some), 601 None => Ok(None), 602 } 603 } 604 size_hint(&self) -> Option<usize>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 } 610 } 611 } 612 613 struct MapDeserializer { 614 iter: <BTreeMap<String, Value> as IntoIterator>::IntoIter, 615 value: Option<(String, Value)>, 616 } 617 618 impl MapDeserializer { new(map: BTreeMap<String, Value>) -> Self619 fn new(map: BTreeMap<String, Value>) -> Self { 620 MapDeserializer { 621 iter: map.into_iter(), 622 value: None, 623 } 624 } 625 } 626 627 impl<'de> de::MapAccess<'de> for MapDeserializer { 628 type Error = ::de::Error; 629 next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ::de::Error> where T: de::DeserializeSeed<'de>,630 fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ::de::Error> 631 where T: de::DeserializeSeed<'de>, 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 next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, ::de::Error> where T: de::DeserializeSeed<'de>,642 fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, ::de::Error> 643 where T: de::DeserializeSeed<'de>, 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 size_hint(&self) -> Option<usize>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 into_deserializer(self) -> Self666 fn into_deserializer(self) -> Self { 667 self 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; 678 type SerializeTuple = SerializeVec; 679 type SerializeTupleStruct = SerializeVec; 680 type SerializeTupleVariant = SerializeVec; 681 type SerializeMap = SerializeMap; 682 type SerializeStruct = SerializeMap; 683 type SerializeStructVariant = ser::Impossible<Value, ::ser::Error>; 684 serialize_bool(self, value: bool) -> Result<Value, ::ser::Error>685 fn serialize_bool(self, value: bool) -> Result<Value, ::ser::Error> { 686 Ok(Value::Boolean(value)) 687 } 688 serialize_i8(self, value: i8) -> Result<Value, ::ser::Error>689 fn serialize_i8(self, value: i8) -> Result<Value, ::ser::Error> { 690 self.serialize_i64(value.into()) 691 } 692 serialize_i16(self, value: i16) -> Result<Value, ::ser::Error>693 fn serialize_i16(self, value: i16) -> Result<Value, ::ser::Error> { 694 self.serialize_i64(value.into()) 695 } 696 serialize_i32(self, value: i32) -> Result<Value, ::ser::Error>697 fn serialize_i32(self, value: i32) -> Result<Value, ::ser::Error> { 698 self.serialize_i64(value.into()) 699 } 700 serialize_i64(self, value: i64) -> Result<Value, ::ser::Error>701 fn serialize_i64(self, value: i64) -> Result<Value, ::ser::Error> { 702 Ok(Value::Integer(value.into())) 703 } 704 serialize_u8(self, value: u8) -> Result<Value, ::ser::Error>705 fn serialize_u8(self, value: u8) -> Result<Value, ::ser::Error> { 706 self.serialize_i64(value.into()) 707 } 708 serialize_u16(self, value: u16) -> Result<Value, ::ser::Error>709 fn serialize_u16(self, value: u16) -> Result<Value, ::ser::Error> { 710 self.serialize_i64(value.into()) 711 } 712 serialize_u32(self, value: u32) -> Result<Value, ::ser::Error>713 fn serialize_u32(self, value: u32) -> Result<Value, ::ser::Error> { 714 self.serialize_i64(value.into()) 715 } 716 serialize_u64(self, value: u64) -> Result<Value, ::ser::Error>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 serialize_f32(self, value: f32) -> Result<Value, ::ser::Error>725 fn serialize_f32(self, value: f32) -> Result<Value, ::ser::Error> { 726 self.serialize_f64(value.into()) 727 } 728 serialize_f64(self, value: f64) -> Result<Value, ::ser::Error>729 fn serialize_f64(self, value: f64) -> Result<Value, ::ser::Error> { 730 Ok(Value::Float(value)) 731 } 732 serialize_char(self, value: char) -> Result<Value, ::ser::Error>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 serialize_str(self, value: &str) -> Result<Value, ::ser::Error>739 fn serialize_str(self, value: &str) -> Result<Value, ::ser::Error> { 740 Ok(Value::String(value.to_owned())) 741 } 742 serialize_bytes(self, value: &[u8]) -> Result<Value, ::ser::Error>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 serialize_unit(self) -> Result<Value, ::ser::Error>748 fn serialize_unit(self) -> Result<Value, ::ser::Error> { 749 Err(::ser::Error::UnsupportedType) 750 } 751 serialize_unit_struct(self, _name: &'static str) -> Result<Value, ::ser::Error>752 fn serialize_unit_struct(self, _name: &'static str) 753 -> Result<Value, ::ser::Error> { 754 Err(::ser::Error::UnsupportedType) 755 } 756 serialize_unit_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str) -> Result<Value, ::ser::Error>757 fn serialize_unit_variant(self, 758 _name: &'static str, 759 _variant_index: u32, 760 _variant: &'static str) 761 -> Result<Value, ::ser::Error> { 762 self.serialize_str(_variant) 763 } 764 serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> Result<Value, ::ser::Error> where T: ser::Serialize,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 serialize_newtype_variant<T: ?Sized>(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _value: &T) -> Result<Value, ::ser::Error> where T: ser::Serialize,774 fn serialize_newtype_variant<T: ?Sized>(self, 775 _name: &'static str, 776 _variant_index: u32, 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 serialize_none(self) -> Result<Value, ::ser::Error>785 fn serialize_none(self) -> Result<Value, ::ser::Error> { 786 Err(::ser::Error::UnsupportedNone) 787 } 788 serialize_some<T: ?Sized>(self, value: &T) -> Result<Value, ::ser::Error> where T: ser::Serialize,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 serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, ::ser::Error>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 serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, ::ser::Error>803 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, ::ser::Error> { 804 self.serialize_seq(Some(len)) 805 } 806 serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, ::ser::Error>807 fn serialize_tuple_struct(self, _name: &'static str, len: usize) 808 -> Result<Self::SerializeTupleStruct, ::ser::Error> { 809 self.serialize_seq(Some(len)) 810 } 811 serialize_tuple_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str, len: usize) -> Result<Self::SerializeTupleVariant, ::ser::Error>812 fn serialize_tuple_variant(self, 813 _name: &'static str, 814 _variant_index: u32, 815 _variant: &'static str, 816 len: usize) 817 -> Result<Self::SerializeTupleVariant, ::ser::Error> 818 { 819 self.serialize_seq(Some(len)) 820 } 821 serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, ::ser::Error>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 serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct, ::ser::Error>831 fn serialize_struct(self, _name: &'static str, len: usize) 832 -> Result<Self::SerializeStruct, ::ser::Error> { 833 self.serialize_map(Some(len)) 834 } 835 serialize_struct_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize) -> Result<Self::SerializeStructVariant, ::ser::Error>836 fn serialize_struct_variant(self, 837 _name: &'static str, 838 _variant_index: u32, 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 serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> where T: ser::Serialize860 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 end(self) -> Result<Value, ::ser::Error>867 fn end(self) -> Result<Value, ::ser::Error> { 868 Ok(Value::Array(self.vec)) 869 } 870 } 871 872 impl ser::SerializeTuple for SerializeVec { 873 type Ok = Value; 874 type Error = ::ser::Error; 875 serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> where T: ser::Serialize876 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 end(self) -> Result<Value, ::ser::Error>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 serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> where T: ser::Serialize891 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 end(self) -> Result<Value, ::ser::Error>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 serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> where T: ser::Serialize906 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 end(self) -> Result<Value, ::ser::Error>912 fn end(self) -> Result<Value, ::ser::Error> { 913 ser::SerializeSeq::end(self) 914 } 915 } 916 917 impl ser::SerializeMap for SerializeMap { 918 type Ok = Value; 919 type Error = ::ser::Error; 920 serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), ::ser::Error> where T: ser::Serialize921 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 serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> where T: ser::Serialize931 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 end(self) -> Result<Value, ::ser::Error>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 serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), ::ser::Error> where T: ser::Serialize953 fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), ::ser::Error> 954 where T: ser::Serialize 955 { 956 ser::SerializeMap::serialize_key(self, key)?; 957 ser::SerializeMap::serialize_value(self, value) 958 } 959 end(self) -> Result<Value, ::ser::Error>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 969 impl<'a, 'de> de::DeserializeSeed<'de> for DatetimeOrTable<'a> { 970 type Value = bool; 971 deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: de::Deserializer<'de>972 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> 973 where D: de::Deserializer<'de> 974 { 975 deserializer.deserialize_any(self) 976 } 977 } 978 979 impl<'a, 'de> de::Visitor<'de> for DatetimeOrTable<'a> { 980 type Value = bool; 981 expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result982 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 983 formatter.write_str("a string key") 984 } 985 visit_str<E>(self, s: &str) -> Result<bool, E> where E: de::Error,986 fn visit_str<E>(self, s: &str) -> Result<bool, E> 987 where E: de::Error, 988 { 989 if s == datetime::FIELD { 990 Ok(true) 991 } else { 992 self.key.push_str(s); 993 Ok(false) 994 } 995 } 996 visit_string<E>(self, s: String) -> Result<bool, E> where E: de::Error,997 fn visit_string<E>(self, s: String) -> Result<bool, E> 998 where E: de::Error, 999 { 1000 if s == datetime::FIELD { 1001 Ok(true) 1002 } else { 1003 *self.key = s; 1004 Ok(false) 1005 } 1006 } 1007 } 1008