toml 0.9.0

A native Rust encoder and decoder of TOML-formatted files and streams. Provides implementations of the standard Serialize/Deserialize traits for TOML data to facilitate deserializing and serializing Rust structures.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use crate::alloc_prelude::*;
use crate::de::DeArray;
use crate::de::DeValue;
use crate::de::Error;

/// Deserializes table values into enum variants.
pub(crate) struct TableEnumDeserializer<'i> {
    value: DeValue<'i>,
    span: core::ops::Range<usize>,
}

impl<'i> TableEnumDeserializer<'i> {
    pub(crate) fn new(value: DeValue<'i>, span: core::ops::Range<usize>) -> Self {
        TableEnumDeserializer { value, span }
    }
}

impl<'de> serde::de::VariantAccess<'de> for TableEnumDeserializer<'de> {
    type Error = Error;

    fn unit_variant(self) -> Result<(), Self::Error> {
        match self.value {
            DeValue::Array(values) => {
                if values.is_empty() {
                    Ok(())
                } else {
                    Err(Error::custom("expected empty array", Some(self.span)))
                }
            }
            DeValue::Table(values) => {
                if values.is_empty() {
                    Ok(())
                } else {
                    Err(Error::custom("expected empty table", Some(self.span)))
                }
            }
            e => Err(Error::custom(
                format!("expected table, found {}", e.type_str()),
                Some(self.span),
            )),
        }
    }

    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
    where
        T: serde::de::DeserializeSeed<'de>,
    {
        seed.deserialize(super::ValueDeserializer::with_parts(self.value, self.span))
    }

    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        match self.value {
            DeValue::Array(values) => {
                let values_span = self.span.clone();
                let tuple_values = values;

                if tuple_values.len() == len {
                    serde::de::Deserializer::deserialize_seq(
                        super::ArrayDeserializer::new(tuple_values, values_span),
                        visitor,
                    )
                } else {
                    Err(Error::custom(
                        format!("expected tuple with length {len}"),
                        Some(values_span),
                    ))
                }
            }
            DeValue::Table(values) => {
                let values_span = self.span.clone();
                let tuple_values: Result<DeArray<'_>, _> = values
                    .into_iter()
                    .enumerate()
                    .map(
                        |(index, (key, value))| match key.get_ref().parse::<usize>() {
                            Ok(key_index) if key_index == index => Ok(value),
                            Ok(_) | Err(_) => Err(Error::custom(
                                format!("expected table key `{index}`, but was `{key}`"),
                                Some(key.span()),
                            )),
                        },
                    )
                    .collect();
                let tuple_values = tuple_values?;

                if tuple_values.len() == len {
                    serde::de::Deserializer::deserialize_seq(
                        super::ArrayDeserializer::new(tuple_values, values_span),
                        visitor,
                    )
                } else {
                    Err(Error::custom(
                        format!("expected tuple with length {len}"),
                        Some(values_span),
                    ))
                }
            }
            e => Err(Error::custom(
                format!("expected table, found {}", e.type_str()),
                Some(self.span),
            )),
        }
    }

    fn struct_variant<V>(
        self,
        fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        serde::de::Deserializer::deserialize_struct(
            super::ValueDeserializer::with_parts(self.value, self.span)
                .with_struct_key_validation(),
            "", // TODO: this should be the variant name
            fields,
            visitor,
        )
    }
}