Struct toml::Decoder

pub struct Decoder {
    pub toml: Option<Value>,
    // some fields omitted
}

A structure to transform TOML values into Rust values.

This decoder implements the serialization Decoder interface, allowing Decodable types to be generated by this decoder. The input is any arbitrary TOML value.

Fields

toml: Option<Value>

The TOML value left over after decoding. This can be used to inspect whether fields were decoded or not.

Methods

impl Decoder

fn new(toml: Value) -> Decoder

Creates a new decoder, consuming the TOML value to decode.

This decoder can be passed to the Decodable methods or driven manually.

Trait Implementations

impl Decoder for Decoder

type Error = DecodeError

fn read_nil(&mut self) -> Result<(), DecodeError>

fn read_usize(&mut self) -> Result<usize, DecodeError>

fn read_u64(&mut self) -> Result<u64, DecodeError>

fn read_u32(&mut self) -> Result<u32, DecodeError>

fn read_u16(&mut self) -> Result<u16, DecodeError>

fn read_u8(&mut self) -> Result<u8, DecodeError>

fn read_isize(&mut self) -> Result<isize, DecodeError>

fn read_i64(&mut self) -> Result<i64, DecodeError>

fn read_i32(&mut self) -> Result<i32, DecodeError>

fn read_i16(&mut self) -> Result<i16, DecodeError>

fn read_i8(&mut self) -> Result<i8, DecodeError>

fn read_bool(&mut self) -> Result<bool, DecodeError>

fn read_f64(&mut self) -> Result<f64, DecodeError>

fn read_f32(&mut self) -> Result<f32, DecodeError>

fn read_char(&mut self) -> Result<char, DecodeError>

fn read_str(&mut self) -> Result<String, DecodeError>

fn read_enum<T, F>(&mut self, _name: &str, f: F) -> Result<T, DecodeError> where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>

fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, DecodeError> where F: FnMut(&mut Decoder, usize) -> Result<T, DecodeError>

fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, f: F) -> Result<T, DecodeError> where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>

fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, DecodeError> where F: FnMut(&mut Decoder, usize) -> Result<T, DecodeError>

fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, DecodeError> where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>

fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, f: F) -> Result<T, DecodeError> where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>

fn read_struct_field<T, F>(&mut self, f_name: &str, _f_idx: usize, f: F) -> Result<T, DecodeError> where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>

fn read_tuple<T, F>(&mut self, tuple_len: usize, f: F) -> Result<T, DecodeError> where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>

fn read_tuple_arg<T, F>(&mut self, a_idx: usize, f: F) -> Result<T, DecodeError> where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>

fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, DecodeError> where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>

fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, DecodeError> where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>

fn read_option<T, F>(&mut self, f: F) -> Result<T, DecodeError> where F: FnMut(&mut Decoder, bool) -> Result<T, DecodeError>

fn read_seq<T, F>(&mut self, f: F) -> Result<T, DecodeError> where F: FnOnce(&mut Decoder, usize) -> Result<T, DecodeError>

fn read_seq_elt<T, F>(&mut self, idx: usize, f: F) -> Result<T, DecodeError> where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>

fn read_map<T, F>(&mut self, f: F) -> Result<T, DecodeError> where F: FnOnce(&mut Decoder, usize) -> Result<T, DecodeError>

fn read_map_elt_key<T, F>(&mut self, idx: usize, f: F) -> Result<T, DecodeError> where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>

fn read_map_elt_val<T, F>(&mut self, idx: usize, f: F) -> Result<T, DecodeError> where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>

fn error(&mut self, err: &str) -> DecodeError

impl Deserializer for Decoder

type Error = DecodeError

The error type that can be returned if some error occurs during deserialization.

fn deserialize<V>(&mut self, visitor: V) -> Result<V::Value, DecodeError> where V: Visitor

This method walks a visitor through a value as it is being deserialized.

fn deserialize_bool<V>(&mut self, visitor: V) -> Result<V::Value, DecodeError> where V: Visitor

This method hints that the Deserialize type is expecting a bool value.

fn deserialize_i64<V>(&mut self, visitor: V) -> Result<V::Value, DecodeError> where V: Visitor

This method hints that the Deserialize type is expecting an i64 value.

fn deserialize_u64<V>(&mut self, v: V) -> Result<V::Value, DecodeError> where V: Visitor

This method hints that the Deserialize type is expecting an u64 value.

fn deserialize_f64<V>(&mut self, visitor: V) -> Result<V::Value, DecodeError> where V: Visitor

This method hints that the Deserialize type is expecting a f64 value.

fn deserialize_str<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting a &str value.

fn deserialize_char<V>(&mut self, visitor: V) -> Result<V::Value, DecodeError> where V: Visitor

This method hints that the Deserialize type is expecting a char value.

fn deserialize_option<V>(&mut self, visitor: V) -> Result<V::Value, DecodeError> where V: Visitor

This method hints that the Deserialize type is expecting an Option value. This allows deserializers that encode an optional value as a nullable value to convert the null value into a None, and a regular value as Some(value).

fn deserialize_seq<V>(&mut self, visitor: V) -> Result<V::Value, DecodeError> where V: Visitor

This method hints that the Deserialize type is expecting a sequence value. This allows deserializers to parse sequences that aren't tagged as sequences.

fn deserialize_map<V>(&mut self, visitor: V) -> Result<V::Value, DecodeError> where V: Visitor

This method hints that the Deserialize type is expecting a map of values. This allows deserializers to parse sequences that aren't tagged as maps.

fn deserialize_enum<V>(&mut self, _enum: &str, variants: &[&str], visitor: V) -> Result<V::Value, DecodeError> where V: EnumVisitor

This method hints that the Deserialize type is expecting an enum value. This allows deserializers that provide a custom enumeration serialization to properly deserialize the type.

fn deserialize_ignored_any<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type needs to deserialize a value whose type doesn't matter because it is ignored.

fn deserialize_usize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting an usize value.

fn deserialize_u8<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting an u8 value.

fn deserialize_u16<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting an u16 value.

fn deserialize_u32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting an u32 value.

fn deserialize_isize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting an isize value.

fn deserialize_i8<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting an i8 value.

fn deserialize_i16<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting an i16 value.

fn deserialize_i32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting an i32 value.

fn deserialize_f32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting a f32 value.

fn deserialize_string<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting a String value.

fn deserialize_unit<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting an unit value.

fn deserialize_fixed_size_array<V>(&mut self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting a fixed size array. This allows deserializers to parse arrays that aren't tagged as arrays.

fn deserialize_bytes<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting a Vec<u8>. This allows deserializers that provide a custom byte vector serialization to properly deserialize the type.

fn deserialize_unit_struct<V>(&mut self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting a unit struct. This allows deserializers to a unit struct that aren't tagged as a unit struct.

fn deserialize_newtype_struct<V>(&mut self, name: &'static str, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting a newtype struct. This allows deserializers to a newtype struct that aren't tagged as a newtype struct.

fn deserialize_tuple_struct<V>(&mut self, _name: &'static str, len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting a tuple struct. This allows deserializers to parse sequences that aren't tagged as sequences.

fn deserialize_struct<V>(&mut self, _name: &'static str, _fields: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting a struct. This allows deserializers to parse sequences that aren't tagged as maps.

fn deserialize_struct_field<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting some sort of struct field name. This allows deserializers to choose between &str, usize, or &[u8] to properly deserialize a struct field.

fn deserialize_tuple<V>(&mut self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor

This method hints that the Deserialize type is expecting a tuple value. This allows deserializers that provide a custom tuple serialization to properly deserialize the type.