toml/
value.rs

1//! Definition of a TOML [value][Value]
2
3use std::collections::{BTreeMap, HashMap};
4use std::fmt;
5use std::hash::Hash;
6use std::mem::discriminant;
7use std::ops;
8use std::vec;
9
10use serde::de;
11use serde::de::IntoDeserializer;
12use serde::ser;
13
14use toml_datetime::__unstable as datetime;
15pub use toml_datetime::{Date, Datetime, DatetimeParseError, Offset, Time};
16
17/// Type representing a TOML array, payload of the `Value::Array` variant
18pub type Array = Vec<Value>;
19
20#[doc(no_inline)]
21pub use crate::Table;
22
23/// Representation of a TOML value.
24#[derive(PartialEq, Clone, Debug)]
25pub enum Value {
26    /// Represents a TOML string
27    String(String),
28    /// Represents a TOML integer
29    Integer(i64),
30    /// Represents a TOML float
31    Float(f64),
32    /// Represents a TOML boolean
33    Boolean(bool),
34    /// Represents a TOML datetime
35    Datetime(Datetime),
36    /// Represents a TOML array
37    Array(Array),
38    /// Represents a TOML table
39    Table(Table),
40}
41
42impl 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, crate::ser::Error>
49    where
50        T: ser::Serialize,
51    {
52        value.serialize(ValueSerializer)
53    }
54
55    /// Interpret a `toml::Value` as an instance of type `T`.
56    ///
57    /// This conversion can fail if the structure of the `Value` does not match the
58    /// structure expected by `T`, for example if `T` is a struct type but the
59    /// `Value` contains something other than a TOML table. It can also fail if the
60    /// structure is correct but `T`'s implementation of `Deserialize` decides that
61    /// something is wrong with the data, for example required struct fields are
62    /// missing from the TOML map or some number is too big to fit in the expected
63    /// primitive type.
64    pub fn try_into<'de, T>(self) -> Result<T, crate::de::Error>
65    where
66        T: de::Deserialize<'de>,
67    {
68        de::Deserialize::deserialize(self)
69    }
70
71    /// Index into a TOML array or map. A string index can be used to access a
72    /// value in a map, and a usize index can be used to access an element of an
73    /// array.
74    ///
75    /// Returns `None` if the type of `self` does not match the type of the
76    /// index, for example if the index is a string and `self` is an array or a
77    /// number. Also returns `None` if the given key does not exist in the map
78    /// or the given index is not within the bounds of the array.
79    pub fn get<I: Index>(&self, index: I) -> Option<&Value> {
80        index.index(self)
81    }
82
83    /// Mutably index into a TOML array or map. A string index can be used to
84    /// access a value in a map, and a usize index can be used to access an
85    /// element of an array.
86    ///
87    /// Returns `None` if the type of `self` does not match the type of the
88    /// index, for example if the index is a string and `self` is an array or a
89    /// number. Also returns `None` if the given key does not exist in the map
90    /// or the given index is not within the bounds of the array.
91    pub fn get_mut<I: Index>(&mut self, index: I) -> Option<&mut Value> {
92        index.index_mut(self)
93    }
94
95    /// Extracts the integer value if it is an integer.
96    pub fn as_integer(&self) -> Option<i64> {
97        match *self {
98            Value::Integer(i) => Some(i),
99            _ => None,
100        }
101    }
102
103    /// Tests whether this value is an integer.
104    pub fn is_integer(&self) -> bool {
105        self.as_integer().is_some()
106    }
107
108    /// Extracts the float value if it is a float.
109    pub fn as_float(&self) -> Option<f64> {
110        match *self {
111            Value::Float(f) => Some(f),
112            _ => None,
113        }
114    }
115
116    /// Tests whether this value is a float.
117    pub fn is_float(&self) -> bool {
118        self.as_float().is_some()
119    }
120
121    /// Extracts the boolean value if it is a boolean.
122    pub fn as_bool(&self) -> Option<bool> {
123        match *self {
124            Value::Boolean(b) => Some(b),
125            _ => None,
126        }
127    }
128
129    /// Tests whether this value is a boolean.
130    pub fn is_bool(&self) -> bool {
131        self.as_bool().is_some()
132    }
133
134    /// Extracts the string of this value if it is a string.
135    pub fn as_str(&self) -> Option<&str> {
136        match *self {
137            Value::String(ref s) => Some(&**s),
138            _ => None,
139        }
140    }
141
142    /// Tests if this value is a string.
143    pub fn is_str(&self) -> bool {
144        self.as_str().is_some()
145    }
146
147    /// Extracts the datetime value if it is a datetime.
148    ///
149    /// Note that a parsed TOML value will only contain ISO 8601 dates. An
150    /// example date is:
151    ///
152    /// ```notrust
153    /// 1979-05-27T07:32:00Z
154    /// ```
155    pub fn as_datetime(&self) -> Option<&Datetime> {
156        match *self {
157            Value::Datetime(ref s) => Some(s),
158            _ => None,
159        }
160    }
161
162    /// Tests whether this value is a datetime.
163    pub fn is_datetime(&self) -> bool {
164        self.as_datetime().is_some()
165    }
166
167    /// Extracts the array value if it is an array.
168    pub fn as_array(&self) -> Option<&Vec<Value>> {
169        match *self {
170            Value::Array(ref s) => Some(s),
171            _ => None,
172        }
173    }
174
175    /// Extracts the array value if it is an array.
176    pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>> {
177        match *self {
178            Value::Array(ref mut s) => Some(s),
179            _ => None,
180        }
181    }
182
183    /// Tests whether this value is an array.
184    pub fn is_array(&self) -> bool {
185        self.as_array().is_some()
186    }
187
188    /// Extracts the table value if it is a table.
189    pub fn as_table(&self) -> Option<&Table> {
190        match *self {
191            Value::Table(ref s) => Some(s),
192            _ => None,
193        }
194    }
195
196    /// Extracts the table value if it is a table.
197    pub fn as_table_mut(&mut self) -> Option<&mut Table> {
198        match *self {
199            Value::Table(ref mut s) => Some(s),
200            _ => None,
201        }
202    }
203
204    /// Tests whether this value is a table.
205    pub fn is_table(&self) -> bool {
206        self.as_table().is_some()
207    }
208
209    /// Tests whether this and another value have the same type.
210    pub fn same_type(&self, other: &Value) -> bool {
211        discriminant(self) == discriminant(other)
212    }
213
214    /// Returns a human-readable representation of the type of this value.
215    pub fn type_str(&self) -> &'static str {
216        match *self {
217            Value::String(..) => "string",
218            Value::Integer(..) => "integer",
219            Value::Float(..) => "float",
220            Value::Boolean(..) => "boolean",
221            Value::Datetime(..) => "datetime",
222            Value::Array(..) => "array",
223            Value::Table(..) => "table",
224        }
225    }
226}
227
228impl<I> ops::Index<I> for Value
229where
230    I: Index,
231{
232    type Output = Value;
233
234    fn index(&self, index: I) -> &Value {
235        self.get(index).expect("index not found")
236    }
237}
238
239impl<I> ops::IndexMut<I> for Value
240where
241    I: Index,
242{
243    fn index_mut(&mut self, index: I) -> &mut Value {
244        self.get_mut(index).expect("index not found")
245    }
246}
247
248impl<'a> From<&'a str> for Value {
249    #[inline]
250    fn from(val: &'a str) -> Value {
251        Value::String(val.to_owned())
252    }
253}
254
255impl<V: Into<Value>> From<Vec<V>> for Value {
256    fn from(val: Vec<V>) -> Value {
257        Value::Array(val.into_iter().map(|v| v.into()).collect())
258    }
259}
260
261impl<S: Into<String>, V: Into<Value>> From<BTreeMap<S, V>> for Value {
262    fn from(val: BTreeMap<S, V>) -> Value {
263        let table = val.into_iter().map(|(s, v)| (s.into(), v.into())).collect();
264
265        Value::Table(table)
266    }
267}
268
269impl<S: Into<String> + Hash + Eq, V: Into<Value>> From<HashMap<S, V>> for Value {
270    fn from(val: HashMap<S, V>) -> Value {
271        let table = val.into_iter().map(|(s, v)| (s.into(), v.into())).collect();
272
273        Value::Table(table)
274    }
275}
276
277macro_rules! impl_into_value {
278    ($variant:ident : $T:ty) => {
279        impl From<$T> for Value {
280            #[inline]
281            fn from(val: $T) -> Value {
282                Value::$variant(val.into())
283            }
284        }
285    };
286}
287
288impl_into_value!(String: String);
289impl_into_value!(Integer: i64);
290impl_into_value!(Integer: i32);
291impl_into_value!(Integer: i8);
292impl_into_value!(Integer: u8);
293impl_into_value!(Integer: u32);
294impl_into_value!(Float: f64);
295impl_into_value!(Float: f32);
296impl_into_value!(Boolean: bool);
297impl_into_value!(Datetime: Datetime);
298impl_into_value!(Table: Table);
299
300/// Types that can be used to index a `toml::Value`
301///
302/// Currently this is implemented for `usize` to index arrays and `str` to index
303/// tables.
304///
305/// This trait is sealed and not intended for implementation outside of the
306/// `toml` crate.
307pub trait Index: Sealed {
308    #[doc(hidden)]
309    fn index<'a>(&self, val: &'a Value) -> Option<&'a Value>;
310    #[doc(hidden)]
311    fn index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value>;
312}
313
314/// An implementation detail that should not be implemented, this will change in
315/// the future and break code otherwise.
316#[doc(hidden)]
317pub trait Sealed {}
318impl Sealed for usize {}
319impl Sealed for str {}
320impl Sealed for String {}
321impl<'a, T: Sealed + ?Sized> Sealed for &'a T {}
322
323impl Index for usize {
324    fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> {
325        match *val {
326            Value::Array(ref a) => a.get(*self),
327            _ => None,
328        }
329    }
330
331    fn index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value> {
332        match *val {
333            Value::Array(ref mut a) => a.get_mut(*self),
334            _ => None,
335        }
336    }
337}
338
339impl Index for str {
340    fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> {
341        match *val {
342            Value::Table(ref a) => a.get(self),
343            _ => None,
344        }
345    }
346
347    fn index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value> {
348        match *val {
349            Value::Table(ref mut a) => a.get_mut(self),
350            _ => None,
351        }
352    }
353}
354
355impl Index for String {
356    fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> {
357        self[..].index(val)
358    }
359
360    fn index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value> {
361        self[..].index_mut(val)
362    }
363}
364
365impl<'s, T> Index for &'s T
366where
367    T: Index + ?Sized,
368{
369    fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> {
370        (**self).index(val)
371    }
372
373    fn index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value> {
374        (**self).index_mut(val)
375    }
376}
377
378#[cfg(feature = "display")]
379impl fmt::Display for Value {
380    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
381        use serde::Serialize as _;
382
383        let mut output = String::new();
384        let serializer = crate::ser::ValueSerializer::new(&mut output);
385        self.serialize(serializer).unwrap();
386        output.fmt(f)
387    }
388}
389
390#[cfg(feature = "parse")]
391impl std::str::FromStr for Value {
392    type Err = crate::de::Error;
393    fn from_str(s: &str) -> Result<Value, Self::Err> {
394        crate::from_str(s)
395    }
396}
397
398impl ser::Serialize for Value {
399    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
400    where
401        S: ser::Serializer,
402    {
403        use serde::ser::SerializeMap;
404
405        match *self {
406            Value::String(ref s) => serializer.serialize_str(s),
407            Value::Integer(i) => serializer.serialize_i64(i),
408            Value::Float(f) => serializer.serialize_f64(f),
409            Value::Boolean(b) => serializer.serialize_bool(b),
410            Value::Datetime(ref s) => s.serialize(serializer),
411            Value::Array(ref a) => a.serialize(serializer),
412            Value::Table(ref t) => {
413                let mut map = serializer.serialize_map(Some(t.len()))?;
414                // Be sure to visit non-tables first (and also non
415                // array-of-tables) as all keys must be emitted first.
416                for (k, v) in t {
417                    if !v.is_table() && !v.is_array()
418                        || (v
419                            .as_array()
420                            .map(|a| !a.iter().any(|v| v.is_table()))
421                            .unwrap_or(false))
422                    {
423                        map.serialize_entry(k, v)?;
424                    }
425                }
426                for (k, v) in t {
427                    if v.as_array()
428                        .map(|a| a.iter().any(|v| v.is_table()))
429                        .unwrap_or(false)
430                    {
431                        map.serialize_entry(k, v)?;
432                    }
433                }
434                for (k, v) in t {
435                    if v.is_table() {
436                        map.serialize_entry(k, v)?;
437                    }
438                }
439                map.end()
440            }
441        }
442    }
443}
444
445impl<'de> de::Deserialize<'de> for Value {
446    fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
447    where
448        D: de::Deserializer<'de>,
449    {
450        struct ValueVisitor;
451
452        impl<'de> de::Visitor<'de> for ValueVisitor {
453            type Value = Value;
454
455            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
456                formatter.write_str("any valid TOML value")
457            }
458
459            fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
460                Ok(Value::Boolean(value))
461            }
462
463            fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
464                Ok(Value::Integer(value))
465            }
466
467            fn visit_u64<E: de::Error>(self, value: u64) -> Result<Value, E> {
468                if i64::try_from(value).is_ok() {
469                    Ok(Value::Integer(value as i64))
470                } else {
471                    Err(de::Error::custom("u64 value was too large"))
472                }
473            }
474
475            fn visit_u32<E>(self, value: u32) -> Result<Value, E> {
476                Ok(Value::Integer(value.into()))
477            }
478
479            fn visit_i32<E>(self, value: i32) -> Result<Value, E> {
480                Ok(Value::Integer(value.into()))
481            }
482
483            fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
484                Ok(Value::Float(value))
485            }
486
487            fn visit_str<E>(self, value: &str) -> Result<Value, E> {
488                Ok(Value::String(value.into()))
489            }
490
491            fn visit_string<E>(self, value: String) -> Result<Value, E> {
492                Ok(Value::String(value))
493            }
494
495            fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
496            where
497                D: de::Deserializer<'de>,
498            {
499                de::Deserialize::deserialize(deserializer)
500            }
501
502            fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
503            where
504                V: de::SeqAccess<'de>,
505            {
506                let mut vec = Vec::new();
507                while let Some(elem) = visitor.next_element()? {
508                    vec.push(elem);
509                }
510                Ok(Value::Array(vec))
511            }
512
513            fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
514            where
515                V: de::MapAccess<'de>,
516            {
517                let mut key = String::new();
518                let datetime = visitor.next_key_seed(DatetimeOrTable { key: &mut key })?;
519                match datetime {
520                    Some(true) => {
521                        let date: datetime::DatetimeFromString = visitor.next_value()?;
522                        return Ok(Value::Datetime(date.value));
523                    }
524                    None => return Ok(Value::Table(Table::new())),
525                    Some(false) => {}
526                }
527                let mut map = Table::new();
528                map.insert(key, visitor.next_value()?);
529                while let Some(key) = visitor.next_key::<String>()? {
530                    if let crate::map::Entry::Vacant(vacant) = map.entry(&key) {
531                        vacant.insert(visitor.next_value()?);
532                    } else {
533                        let msg = format!("duplicate key: `{}`", key);
534                        return Err(de::Error::custom(msg));
535                    }
536                }
537                Ok(Value::Table(map))
538            }
539        }
540
541        deserializer.deserialize_any(ValueVisitor)
542    }
543}
544
545// This is wrapped by `Table` and any trait methods implemented here need to be wrapped there.
546impl<'de> de::Deserializer<'de> for Value {
547    type Error = crate::de::Error;
548
549    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, crate::de::Error>
550    where
551        V: de::Visitor<'de>,
552    {
553        match self {
554            Value::Boolean(v) => visitor.visit_bool(v),
555            Value::Integer(n) => visitor.visit_i64(n),
556            Value::Float(n) => visitor.visit_f64(n),
557            Value::String(v) => visitor.visit_string(v),
558            Value::Datetime(v) => visitor.visit_string(v.to_string()),
559            Value::Array(v) => {
560                let len = v.len();
561                let mut deserializer = SeqDeserializer::new(v);
562                let seq = visitor.visit_seq(&mut deserializer)?;
563                let remaining = deserializer.iter.len();
564                if remaining == 0 {
565                    Ok(seq)
566                } else {
567                    Err(de::Error::invalid_length(len, &"fewer elements in array"))
568                }
569            }
570            Value::Table(v) => {
571                let len = v.len();
572                let mut deserializer = MapDeserializer::new(v);
573                let map = visitor.visit_map(&mut deserializer)?;
574                let remaining = deserializer.iter.len();
575                if remaining == 0 {
576                    Ok(map)
577                } else {
578                    Err(de::Error::invalid_length(len, &"fewer elements in map"))
579                }
580            }
581        }
582    }
583
584    #[inline]
585    fn deserialize_enum<V>(
586        self,
587        _name: &'static str,
588        _variants: &'static [&'static str],
589        visitor: V,
590    ) -> Result<V::Value, crate::de::Error>
591    where
592        V: de::Visitor<'de>,
593    {
594        match self {
595            Value::String(variant) => visitor.visit_enum(variant.into_deserializer()),
596            Value::Table(variant) => {
597                use de::Error;
598                if variant.is_empty() {
599                    Err(crate::de::Error::custom(
600                        "wanted exactly 1 element, found 0 elements",
601                    ))
602                } else if variant.len() != 1 {
603                    Err(crate::de::Error::custom(
604                        "wanted exactly 1 element, more than 1 element",
605                    ))
606                } else {
607                    let deserializer = MapDeserializer::new(variant);
608                    visitor.visit_enum(deserializer)
609                }
610            }
611            _ => Err(de::Error::invalid_type(
612                de::Unexpected::UnitVariant,
613                &"string only",
614            )),
615        }
616    }
617
618    // `None` is interpreted as a missing field so be sure to implement `Some`
619    // as a present field.
620    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, crate::de::Error>
621    where
622        V: de::Visitor<'de>,
623    {
624        visitor.visit_some(self)
625    }
626
627    fn deserialize_newtype_struct<V>(
628        self,
629        _name: &'static str,
630        visitor: V,
631    ) -> Result<V::Value, crate::de::Error>
632    where
633        V: de::Visitor<'de>,
634    {
635        visitor.visit_newtype_struct(self)
636    }
637
638    serde::forward_to_deserialize_any! {
639        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq
640        bytes byte_buf map unit_struct tuple_struct struct
641        tuple ignored_any identifier
642    }
643}
644
645struct SeqDeserializer {
646    iter: vec::IntoIter<Value>,
647}
648
649impl SeqDeserializer {
650    fn new(vec: Vec<Value>) -> Self {
651        SeqDeserializer {
652            iter: vec.into_iter(),
653        }
654    }
655}
656
657impl<'de> de::SeqAccess<'de> for SeqDeserializer {
658    type Error = crate::de::Error;
659
660    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, crate::de::Error>
661    where
662        T: de::DeserializeSeed<'de>,
663    {
664        match self.iter.next() {
665            Some(value) => seed.deserialize(value).map(Some),
666            None => Ok(None),
667        }
668    }
669
670    fn size_hint(&self) -> Option<usize> {
671        match self.iter.size_hint() {
672            (lower, Some(upper)) if lower == upper => Some(upper),
673            _ => None,
674        }
675    }
676}
677
678struct MapDeserializer {
679    iter: <Table as IntoIterator>::IntoIter,
680    value: Option<(String, Value)>,
681}
682
683impl MapDeserializer {
684    fn new(map: Table) -> Self {
685        MapDeserializer {
686            iter: map.into_iter(),
687            value: None,
688        }
689    }
690}
691
692impl<'de> de::MapAccess<'de> for MapDeserializer {
693    type Error = crate::de::Error;
694
695    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, crate::de::Error>
696    where
697        T: de::DeserializeSeed<'de>,
698    {
699        match self.iter.next() {
700            Some((key, value)) => {
701                self.value = Some((key.clone(), value));
702                seed.deserialize(Value::String(key)).map(Some)
703            }
704            None => Ok(None),
705        }
706    }
707
708    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, crate::de::Error>
709    where
710        T: de::DeserializeSeed<'de>,
711    {
712        let (key, res) = match self.value.take() {
713            Some((key, value)) => (key, seed.deserialize(value)),
714            None => return Err(de::Error::custom("value is missing")),
715        };
716        res.map_err(|mut error| {
717            error.add_key(key);
718            error
719        })
720    }
721
722    fn size_hint(&self) -> Option<usize> {
723        match self.iter.size_hint() {
724            (lower, Some(upper)) if lower == upper => Some(upper),
725            _ => None,
726        }
727    }
728}
729
730impl<'de> de::EnumAccess<'de> for MapDeserializer {
731    type Error = crate::de::Error;
732    type Variant = MapEnumDeserializer;
733
734    fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
735    where
736        V: de::DeserializeSeed<'de>,
737    {
738        use de::Error;
739        let (key, value) = match self.iter.next() {
740            Some(pair) => pair,
741            None => {
742                return Err(Error::custom(
743                    "expected table with exactly 1 entry, found empty table",
744                ));
745            }
746        };
747
748        let val = seed.deserialize(key.into_deserializer())?;
749
750        let variant = MapEnumDeserializer::new(value);
751
752        Ok((val, variant))
753    }
754}
755
756/// Deserializes table values into enum variants.
757pub(crate) struct MapEnumDeserializer {
758    value: Value,
759}
760
761impl MapEnumDeserializer {
762    pub(crate) fn new(value: Value) -> Self {
763        MapEnumDeserializer { value }
764    }
765}
766
767impl<'de> de::VariantAccess<'de> for MapEnumDeserializer {
768    type Error = crate::de::Error;
769
770    fn unit_variant(self) -> Result<(), Self::Error> {
771        use de::Error;
772        match self.value {
773            Value::Array(values) => {
774                if values.is_empty() {
775                    Ok(())
776                } else {
777                    Err(Error::custom("expected empty array"))
778                }
779            }
780            Value::Table(values) => {
781                if values.is_empty() {
782                    Ok(())
783                } else {
784                    Err(Error::custom("expected empty table"))
785                }
786            }
787            e => Err(Error::custom(format!(
788                "expected table, found {}",
789                e.type_str()
790            ))),
791        }
792    }
793
794    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
795    where
796        T: de::DeserializeSeed<'de>,
797    {
798        seed.deserialize(self.value.into_deserializer())
799    }
800
801    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
802    where
803        V: de::Visitor<'de>,
804    {
805        use de::Error;
806        match self.value {
807            Value::Array(values) => {
808                if values.len() == len {
809                    de::Deserializer::deserialize_seq(values.into_deserializer(), visitor)
810                } else {
811                    Err(Error::custom(format!("expected tuple with length {}", len)))
812                }
813            }
814            Value::Table(values) => {
815                let tuple_values: Result<Vec<_>, _> = values
816                    .into_iter()
817                    .enumerate()
818                    .map(|(index, (key, value))| match key.parse::<usize>() {
819                        Ok(key_index) if key_index == index => Ok(value),
820                        Ok(_) | Err(_) => Err(Error::custom(format!(
821                            "expected table key `{}`, but was `{}`",
822                            index, key
823                        ))),
824                    })
825                    .collect();
826                let tuple_values = tuple_values?;
827
828                if tuple_values.len() == len {
829                    de::Deserializer::deserialize_seq(tuple_values.into_deserializer(), visitor)
830                } else {
831                    Err(Error::custom(format!("expected tuple with length {}", len)))
832                }
833            }
834            e => Err(Error::custom(format!(
835                "expected table, found {}",
836                e.type_str()
837            ))),
838        }
839    }
840
841    fn struct_variant<V>(
842        self,
843        fields: &'static [&'static str],
844        visitor: V,
845    ) -> Result<V::Value, Self::Error>
846    where
847        V: de::Visitor<'de>,
848    {
849        de::Deserializer::deserialize_struct(
850            self.value.into_deserializer(),
851            "", // TODO: this should be the variant name
852            fields,
853            visitor,
854        )
855    }
856}
857
858impl<'de> IntoDeserializer<'de, crate::de::Error> for Value {
859    type Deserializer = Self;
860
861    fn into_deserializer(self) -> Self {
862        self
863    }
864}
865
866struct ValueSerializer;
867
868impl ser::Serializer for ValueSerializer {
869    type Ok = Value;
870    type Error = crate::ser::Error;
871
872    type SerializeSeq = ValueSerializeVec;
873    type SerializeTuple = ValueSerializeVec;
874    type SerializeTupleStruct = ValueSerializeVec;
875    type SerializeTupleVariant = ValueSerializeTupleVariant;
876    type SerializeMap = ValueSerializeMap;
877    type SerializeStruct = ValueSerializeMap;
878    type SerializeStructVariant = ValueSerializeStructVariant;
879
880    fn serialize_bool(self, value: bool) -> Result<Value, crate::ser::Error> {
881        Ok(Value::Boolean(value))
882    }
883
884    fn serialize_i8(self, value: i8) -> Result<Value, crate::ser::Error> {
885        self.serialize_i64(value.into())
886    }
887
888    fn serialize_i16(self, value: i16) -> Result<Value, crate::ser::Error> {
889        self.serialize_i64(value.into())
890    }
891
892    fn serialize_i32(self, value: i32) -> Result<Value, crate::ser::Error> {
893        self.serialize_i64(value.into())
894    }
895
896    fn serialize_i64(self, value: i64) -> Result<Value, crate::ser::Error> {
897        Ok(Value::Integer(value))
898    }
899
900    fn serialize_u8(self, value: u8) -> Result<Value, crate::ser::Error> {
901        self.serialize_i64(value.into())
902    }
903
904    fn serialize_u16(self, value: u16) -> Result<Value, crate::ser::Error> {
905        self.serialize_i64(value.into())
906    }
907
908    fn serialize_u32(self, value: u32) -> Result<Value, crate::ser::Error> {
909        self.serialize_i64(value.into())
910    }
911
912    fn serialize_u64(self, value: u64) -> Result<Value, crate::ser::Error> {
913        if i64::try_from(value).is_ok() {
914            self.serialize_i64(value as i64)
915        } else {
916            Err(ser::Error::custom("u64 value was too large"))
917        }
918    }
919
920    fn serialize_f32(self, value: f32) -> Result<Value, crate::ser::Error> {
921        self.serialize_f64(value as f64)
922    }
923
924    fn serialize_f64(self, mut value: f64) -> Result<Value, crate::ser::Error> {
925        // Discard sign of NaN. See ValueSerializer::serialize_f64.
926        if value.is_nan() {
927            value = value.copysign(1.0);
928        }
929        Ok(Value::Float(value))
930    }
931
932    fn serialize_char(self, value: char) -> Result<Value, crate::ser::Error> {
933        let mut s = String::new();
934        s.push(value);
935        self.serialize_str(&s)
936    }
937
938    fn serialize_str(self, value: &str) -> Result<Value, crate::ser::Error> {
939        Ok(Value::String(value.to_owned()))
940    }
941
942    fn serialize_bytes(self, value: &[u8]) -> Result<Value, crate::ser::Error> {
943        let vec = value.iter().map(|&b| Value::Integer(b.into())).collect();
944        Ok(Value::Array(vec))
945    }
946
947    fn serialize_unit(self) -> Result<Value, crate::ser::Error> {
948        Err(crate::ser::Error::unsupported_type(Some("unit")))
949    }
950
951    fn serialize_unit_struct(self, name: &'static str) -> Result<Value, crate::ser::Error> {
952        Err(crate::ser::Error::unsupported_type(Some(name)))
953    }
954
955    fn serialize_unit_variant(
956        self,
957        _name: &'static str,
958        _variant_index: u32,
959        _variant: &'static str,
960    ) -> Result<Value, crate::ser::Error> {
961        self.serialize_str(_variant)
962    }
963
964    fn serialize_newtype_struct<T>(
965        self,
966        _name: &'static str,
967        value: &T,
968    ) -> Result<Value, crate::ser::Error>
969    where
970        T: ser::Serialize + ?Sized,
971    {
972        value.serialize(self)
973    }
974
975    fn serialize_newtype_variant<T>(
976        self,
977        _name: &'static str,
978        _variant_index: u32,
979        variant: &'static str,
980        value: &T,
981    ) -> Result<Value, crate::ser::Error>
982    where
983        T: ser::Serialize + ?Sized,
984    {
985        let value = value.serialize(ValueSerializer)?;
986        let mut table = Table::new();
987        table.insert(variant.to_owned(), value);
988        Ok(table.into())
989    }
990
991    fn serialize_none(self) -> Result<Value, crate::ser::Error> {
992        Err(crate::ser::Error::unsupported_none())
993    }
994
995    fn serialize_some<T>(self, value: &T) -> Result<Value, crate::ser::Error>
996    where
997        T: ser::Serialize + ?Sized,
998    {
999        value.serialize(self)
1000    }
1001
1002    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, crate::ser::Error> {
1003        Ok(ValueSerializeVec {
1004            vec: Vec::with_capacity(len.unwrap_or(0)),
1005        })
1006    }
1007
1008    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, crate::ser::Error> {
1009        self.serialize_seq(Some(len))
1010    }
1011
1012    fn serialize_tuple_struct(
1013        self,
1014        _name: &'static str,
1015        len: usize,
1016    ) -> Result<Self::SerializeTupleStruct, crate::ser::Error> {
1017        self.serialize_seq(Some(len))
1018    }
1019
1020    fn serialize_tuple_variant(
1021        self,
1022        _name: &'static str,
1023        _variant_index: u32,
1024        variant: &'static str,
1025        len: usize,
1026    ) -> Result<Self::SerializeTupleVariant, crate::ser::Error> {
1027        Ok(ValueSerializeTupleVariant::tuple(variant, len))
1028    }
1029
1030    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, crate::ser::Error> {
1031        Ok(ValueSerializeMap {
1032            ser: SerializeMap {
1033                map: Table::new(),
1034                next_key: None,
1035            },
1036        })
1037    }
1038
1039    fn serialize_struct(
1040        self,
1041        _name: &'static str,
1042        len: usize,
1043    ) -> Result<Self::SerializeStruct, crate::ser::Error> {
1044        self.serialize_map(Some(len))
1045    }
1046
1047    fn serialize_struct_variant(
1048        self,
1049        _name: &'static str,
1050        _variant_index: u32,
1051        variant: &'static str,
1052        len: usize,
1053    ) -> Result<Self::SerializeStructVariant, crate::ser::Error> {
1054        Ok(ValueSerializeStructVariant::struct_(variant, len))
1055    }
1056}
1057
1058pub(crate) struct TableSerializer;
1059
1060impl ser::Serializer for TableSerializer {
1061    type Ok = Table;
1062    type Error = crate::ser::Error;
1063
1064    type SerializeSeq = ser::Impossible<Table, crate::ser::Error>;
1065    type SerializeTuple = ser::Impossible<Table, crate::ser::Error>;
1066    type SerializeTupleStruct = ser::Impossible<Table, crate::ser::Error>;
1067    type SerializeTupleVariant = ser::Impossible<Table, crate::ser::Error>;
1068    type SerializeMap = SerializeMap;
1069    type SerializeStruct = SerializeMap;
1070    type SerializeStructVariant = ser::Impossible<Table, crate::ser::Error>;
1071
1072    fn serialize_bool(self, _value: bool) -> Result<Table, crate::ser::Error> {
1073        Err(crate::ser::Error::unsupported_type(None))
1074    }
1075
1076    fn serialize_i8(self, _value: i8) -> Result<Table, crate::ser::Error> {
1077        Err(crate::ser::Error::unsupported_type(None))
1078    }
1079
1080    fn serialize_i16(self, _value: i16) -> Result<Table, crate::ser::Error> {
1081        Err(crate::ser::Error::unsupported_type(None))
1082    }
1083
1084    fn serialize_i32(self, _value: i32) -> Result<Table, crate::ser::Error> {
1085        Err(crate::ser::Error::unsupported_type(None))
1086    }
1087
1088    fn serialize_i64(self, _value: i64) -> Result<Table, crate::ser::Error> {
1089        Err(crate::ser::Error::unsupported_type(None))
1090    }
1091
1092    fn serialize_u8(self, _value: u8) -> Result<Table, crate::ser::Error> {
1093        Err(crate::ser::Error::unsupported_type(None))
1094    }
1095
1096    fn serialize_u16(self, _value: u16) -> Result<Table, crate::ser::Error> {
1097        Err(crate::ser::Error::unsupported_type(None))
1098    }
1099
1100    fn serialize_u32(self, _value: u32) -> Result<Table, crate::ser::Error> {
1101        Err(crate::ser::Error::unsupported_type(None))
1102    }
1103
1104    fn serialize_u64(self, _value: u64) -> Result<Table, crate::ser::Error> {
1105        Err(crate::ser::Error::unsupported_type(None))
1106    }
1107
1108    fn serialize_f32(self, _value: f32) -> Result<Table, crate::ser::Error> {
1109        Err(crate::ser::Error::unsupported_type(None))
1110    }
1111
1112    fn serialize_f64(self, _value: f64) -> Result<Table, crate::ser::Error> {
1113        Err(crate::ser::Error::unsupported_type(None))
1114    }
1115
1116    fn serialize_char(self, _value: char) -> Result<Table, crate::ser::Error> {
1117        Err(crate::ser::Error::unsupported_type(None))
1118    }
1119
1120    fn serialize_str(self, _value: &str) -> Result<Table, crate::ser::Error> {
1121        Err(crate::ser::Error::unsupported_type(None))
1122    }
1123
1124    fn serialize_bytes(self, _value: &[u8]) -> Result<Table, crate::ser::Error> {
1125        Err(crate::ser::Error::unsupported_type(None))
1126    }
1127
1128    fn serialize_unit(self) -> Result<Table, crate::ser::Error> {
1129        Err(crate::ser::Error::unsupported_type(None))
1130    }
1131
1132    fn serialize_unit_struct(self, _name: &'static str) -> Result<Table, crate::ser::Error> {
1133        Err(crate::ser::Error::unsupported_type(None))
1134    }
1135
1136    fn serialize_unit_variant(
1137        self,
1138        name: &'static str,
1139        _variant_index: u32,
1140        _variant: &'static str,
1141    ) -> Result<Table, crate::ser::Error> {
1142        Err(crate::ser::Error::unsupported_type(Some(name)))
1143    }
1144
1145    fn serialize_newtype_struct<T>(
1146        self,
1147        _name: &'static str,
1148        value: &T,
1149    ) -> Result<Table, crate::ser::Error>
1150    where
1151        T: ser::Serialize + ?Sized,
1152    {
1153        value.serialize(self)
1154    }
1155
1156    fn serialize_newtype_variant<T>(
1157        self,
1158        _name: &'static str,
1159        _variant_index: u32,
1160        variant: &'static str,
1161        value: &T,
1162    ) -> Result<Table, crate::ser::Error>
1163    where
1164        T: ser::Serialize + ?Sized,
1165    {
1166        let value = value.serialize(ValueSerializer)?;
1167        let mut table = Table::new();
1168        table.insert(variant.to_owned(), value);
1169        Ok(table)
1170    }
1171
1172    fn serialize_none(self) -> Result<Table, crate::ser::Error> {
1173        Err(crate::ser::Error::unsupported_none())
1174    }
1175
1176    fn serialize_some<T>(self, value: &T) -> Result<Table, crate::ser::Error>
1177    where
1178        T: ser::Serialize + ?Sized,
1179    {
1180        value.serialize(self)
1181    }
1182
1183    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, crate::ser::Error> {
1184        Err(crate::ser::Error::unsupported_type(None))
1185    }
1186
1187    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, crate::ser::Error> {
1188        Err(crate::ser::Error::unsupported_type(None))
1189    }
1190
1191    fn serialize_tuple_struct(
1192        self,
1193        name: &'static str,
1194        _len: usize,
1195    ) -> Result<Self::SerializeTupleStruct, crate::ser::Error> {
1196        Err(crate::ser::Error::unsupported_type(Some(name)))
1197    }
1198
1199    fn serialize_tuple_variant(
1200        self,
1201        name: &'static str,
1202        _variant_index: u32,
1203        _variant: &'static str,
1204        _len: usize,
1205    ) -> Result<Self::SerializeTupleVariant, crate::ser::Error> {
1206        Err(crate::ser::Error::unsupported_type(Some(name)))
1207    }
1208
1209    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, crate::ser::Error> {
1210        Ok(SerializeMap {
1211            map: Table::new(),
1212            next_key: None,
1213        })
1214    }
1215
1216    fn serialize_struct(
1217        self,
1218        _name: &'static str,
1219        len: usize,
1220    ) -> Result<Self::SerializeStruct, crate::ser::Error> {
1221        self.serialize_map(Some(len))
1222    }
1223
1224    fn serialize_struct_variant(
1225        self,
1226        name: &'static str,
1227        _variant_index: u32,
1228        _variant: &'static str,
1229        _len: usize,
1230    ) -> Result<Self::SerializeStructVariant, crate::ser::Error> {
1231        Err(crate::ser::Error::unsupported_type(Some(name)))
1232    }
1233}
1234
1235struct ValueSerializeVec {
1236    vec: Vec<Value>,
1237}
1238
1239impl ser::SerializeSeq for ValueSerializeVec {
1240    type Ok = Value;
1241    type Error = crate::ser::Error;
1242
1243    fn serialize_element<T>(&mut self, value: &T) -> Result<(), crate::ser::Error>
1244    where
1245        T: ser::Serialize + ?Sized,
1246    {
1247        self.vec.push(Value::try_from(value)?);
1248        Ok(())
1249    }
1250
1251    fn end(self) -> Result<Value, crate::ser::Error> {
1252        Ok(Value::Array(self.vec))
1253    }
1254}
1255
1256impl ser::SerializeTuple for ValueSerializeVec {
1257    type Ok = Value;
1258    type Error = crate::ser::Error;
1259
1260    fn serialize_element<T>(&mut self, value: &T) -> Result<(), crate::ser::Error>
1261    where
1262        T: ser::Serialize + ?Sized,
1263    {
1264        ser::SerializeSeq::serialize_element(self, value)
1265    }
1266
1267    fn end(self) -> Result<Value, crate::ser::Error> {
1268        ser::SerializeSeq::end(self)
1269    }
1270}
1271
1272impl ser::SerializeTupleStruct for ValueSerializeVec {
1273    type Ok = Value;
1274    type Error = crate::ser::Error;
1275
1276    fn serialize_field<T>(&mut self, value: &T) -> Result<(), crate::ser::Error>
1277    where
1278        T: ser::Serialize + ?Sized,
1279    {
1280        ser::SerializeSeq::serialize_element(self, value)
1281    }
1282
1283    fn end(self) -> Result<Value, crate::ser::Error> {
1284        ser::SerializeSeq::end(self)
1285    }
1286}
1287
1288impl ser::SerializeTupleVariant for ValueSerializeVec {
1289    type Ok = Value;
1290    type Error = crate::ser::Error;
1291
1292    fn serialize_field<T>(&mut self, value: &T) -> Result<(), crate::ser::Error>
1293    where
1294        T: ser::Serialize + ?Sized,
1295    {
1296        ser::SerializeSeq::serialize_element(self, value)
1297    }
1298
1299    fn end(self) -> Result<Value, crate::ser::Error> {
1300        ser::SerializeSeq::end(self)
1301    }
1302}
1303
1304pub(crate) struct SerializeMap {
1305    map: Table,
1306    next_key: Option<String>,
1307}
1308
1309impl ser::SerializeMap for SerializeMap {
1310    type Ok = Table;
1311    type Error = crate::ser::Error;
1312
1313    fn serialize_key<T>(&mut self, key: &T) -> Result<(), crate::ser::Error>
1314    where
1315        T: ser::Serialize + ?Sized,
1316    {
1317        match Value::try_from(key)? {
1318            Value::String(s) => self.next_key = Some(s),
1319            _ => return Err(crate::ser::Error::key_not_string()),
1320        };
1321        Ok(())
1322    }
1323
1324    fn serialize_value<T>(&mut self, value: &T) -> Result<(), crate::ser::Error>
1325    where
1326        T: ser::Serialize + ?Sized,
1327    {
1328        let key = self.next_key.take();
1329        let key = key.expect("serialize_value called before serialize_key");
1330        match Value::try_from(value) {
1331            Ok(value) => {
1332                self.map.insert(key, value);
1333            }
1334            Err(crate::ser::Error {
1335                inner: crate::edit::ser::Error::UnsupportedNone,
1336            }) => {}
1337            Err(e) => return Err(e),
1338        }
1339        Ok(())
1340    }
1341
1342    fn end(self) -> Result<Table, crate::ser::Error> {
1343        Ok(self.map)
1344    }
1345}
1346
1347impl ser::SerializeStruct for SerializeMap {
1348    type Ok = Table;
1349    type Error = crate::ser::Error;
1350
1351    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), crate::ser::Error>
1352    where
1353        T: ser::Serialize + ?Sized,
1354    {
1355        ser::SerializeMap::serialize_key(self, key)?;
1356        ser::SerializeMap::serialize_value(self, value)
1357    }
1358
1359    fn end(self) -> Result<Table, crate::ser::Error> {
1360        ser::SerializeMap::end(self)
1361    }
1362}
1363
1364struct ValueSerializeMap {
1365    ser: SerializeMap,
1366}
1367
1368impl ser::SerializeMap for ValueSerializeMap {
1369    type Ok = Value;
1370    type Error = crate::ser::Error;
1371
1372    fn serialize_key<T>(&mut self, key: &T) -> Result<(), crate::ser::Error>
1373    where
1374        T: ser::Serialize + ?Sized,
1375    {
1376        self.ser.serialize_key(key)
1377    }
1378
1379    fn serialize_value<T>(&mut self, value: &T) -> Result<(), crate::ser::Error>
1380    where
1381        T: ser::Serialize + ?Sized,
1382    {
1383        self.ser.serialize_value(value)
1384    }
1385
1386    fn end(self) -> Result<Value, crate::ser::Error> {
1387        self.ser.end().map(Value::Table)
1388    }
1389}
1390
1391impl ser::SerializeStruct for ValueSerializeMap {
1392    type Ok = Value;
1393    type Error = crate::ser::Error;
1394
1395    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), crate::ser::Error>
1396    where
1397        T: ser::Serialize + ?Sized,
1398    {
1399        ser::SerializeMap::serialize_key(self, key)?;
1400        ser::SerializeMap::serialize_value(self, value)
1401    }
1402
1403    fn end(self) -> Result<Value, crate::ser::Error> {
1404        ser::SerializeMap::end(self)
1405    }
1406}
1407
1408struct DatetimeOrTable<'a> {
1409    key: &'a mut String,
1410}
1411
1412impl<'a, 'de> de::DeserializeSeed<'de> for DatetimeOrTable<'a> {
1413    type Value = bool;
1414
1415    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1416    where
1417        D: de::Deserializer<'de>,
1418    {
1419        deserializer.deserialize_any(self)
1420    }
1421}
1422
1423impl<'a, 'de> de::Visitor<'de> for DatetimeOrTable<'a> {
1424    type Value = bool;
1425
1426    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
1427        formatter.write_str("a string key")
1428    }
1429
1430    fn visit_str<E>(self, s: &str) -> Result<bool, E>
1431    where
1432        E: de::Error,
1433    {
1434        if s == datetime::FIELD {
1435            Ok(true)
1436        } else {
1437            self.key.push_str(s);
1438            Ok(false)
1439        }
1440    }
1441
1442    fn visit_string<E>(self, s: String) -> Result<bool, E>
1443    where
1444        E: de::Error,
1445    {
1446        if s == datetime::FIELD {
1447            Ok(true)
1448        } else {
1449            *self.key = s;
1450            Ok(false)
1451        }
1452    }
1453}
1454
1455type ValueSerializeTupleVariant = ValueSerializeVariant<ValueSerializeVec>;
1456type ValueSerializeStructVariant = ValueSerializeVariant<ValueSerializeMap>;
1457
1458struct ValueSerializeVariant<T> {
1459    variant: &'static str,
1460    inner: T,
1461}
1462
1463impl ValueSerializeVariant<ValueSerializeVec> {
1464    pub(crate) fn tuple(variant: &'static str, len: usize) -> Self {
1465        Self {
1466            variant,
1467            inner: ValueSerializeVec {
1468                vec: Vec::with_capacity(len),
1469            },
1470        }
1471    }
1472}
1473
1474impl ValueSerializeVariant<ValueSerializeMap> {
1475    pub(crate) fn struct_(variant: &'static str, len: usize) -> Self {
1476        Self {
1477            variant,
1478            inner: ValueSerializeMap {
1479                ser: SerializeMap {
1480                    map: Table::with_capacity(len),
1481                    next_key: None,
1482                },
1483            },
1484        }
1485    }
1486}
1487
1488impl ser::SerializeTupleVariant for ValueSerializeVariant<ValueSerializeVec> {
1489    type Ok = Value;
1490    type Error = crate::ser::Error;
1491
1492    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
1493    where
1494        T: ser::Serialize + ?Sized,
1495    {
1496        ser::SerializeSeq::serialize_element(&mut self.inner, value)
1497    }
1498
1499    fn end(self) -> Result<Self::Ok, Self::Error> {
1500        let inner = ser::SerializeSeq::end(self.inner)?;
1501        let mut table = Table::new();
1502        table.insert(self.variant.to_owned(), inner);
1503        Ok(Value::Table(table))
1504    }
1505}
1506
1507impl ser::SerializeStructVariant for ValueSerializeVariant<ValueSerializeMap> {
1508    type Ok = Value;
1509    type Error = crate::ser::Error;
1510
1511    #[inline]
1512    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
1513    where
1514        T: ser::Serialize + ?Sized,
1515    {
1516        ser::SerializeStruct::serialize_field(&mut self.inner, key, value)
1517    }
1518
1519    #[inline]
1520    fn end(self) -> Result<Self::Ok, Self::Error> {
1521        let inner = ser::SerializeStruct::end(self.inner)?;
1522        let mut table = Table::new();
1523        table.insert(self.variant.to_owned(), inner);
1524        Ok(Value::Table(table))
1525    }
1526}
toml/value.rs

toml/
value.rs
