Struct serde_keyvalue::KeyValueDeserializer

pub struct KeyValueDeserializer<'de> {
    original_input: &'de str,
    input: &'de str,
    next_identifier: Option<&'de str>,
    has_equal: bool,
    top_struct_parsed: bool,
}

Serde deserializer for key-values strings.

Fields

original_input: &'de str

Full input originally received for parsing.

input: &'de str

Input currently remaining to parse.

next_identifier: Option<&'de str>

If set, then deserialize_identifier will take and return its content the next time it is called instead of trying to parse an identifier from the input. This is needed to allow the name of the first field of a struct to be omitted, e.g.

–block “/path/to/disk.img,ro=true”

instead of

–block “path=/path/to/disk.img,ro=true”

has_equal: bool

Whether the ‘=’ sign has been parsed after a key. The absence of ‘=’ is only valid for boolean fields, in which case the field’s value will be true.

top_struct_parsed: bool

Whether the top structure has been parsed yet or not. The top structure is the only one that does not require to be enclosed within braces.

Implementations

impl<'de> KeyValueDeserializer<'de>

pub fn error_here(&self, kind: ErrorKind) -> ParseError

Return an kind error for the current position of the input.

pub fn peek_char(&self) -> Option<char>

Returns the next char in the input string without consuming it, or None if we reached the end of input.

pub fn skip_char(&mut self)

Skip the next char in the input string.

pub fn next_char(&mut self) -> Option<char>

Returns the next char in the input string and consume it, or returns None if we reached the end of input.

fn confirm_separator(&mut self) -> Result<(), ParseError>

Confirm that we have a separator (i.e. ‘,’ or ‘]’) character or have reached the end of the input string.

pub fn parse_identifier(&mut self) -> Result<&'de str, ParseError>

Attempts to parse an identifier, either for a key or for the value of an enum type.

pub fn parse_string(&mut self) -> Result<Cow<'de, str>, ParseError>

Attempts to parse a string.

pub fn parse_bool(&mut self) -> Result<bool, ParseError>

Attempt to parse a boolean.

pub fn parse_number<T>(&mut self) -> Result<T, ParseError>

where T: Num<FromStrRadixErr = ParseIntError>,

Attempt to parse a positive or negative number.

pub fn finish(self) -> Result<(), ParseError>

Consume this deserializer and return a TrailingCharacters error if some input was remaining.

This is useful to confirm that the whole input has been consumed without any extra elements.

Trait Implementations

impl<'de, 'a> Deserializer<'de> for &'a mut KeyValueDeserializer<'de>

type Error = ParseError

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

fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Require the Deserializer to figure out how to drive the visitor based on what data type is in the input.

fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a bool value.

fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i8 value.

fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i16 value.

fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i32 value.

fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i64 value.

fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u8 value.

fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u16 value.

fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u32 value.

fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u64 value.

fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a f32 value.

fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a f64 value.

fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a char value.

fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a string value and does not benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a string value and would benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a byte array and does not benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a byte array and would benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an optional value.

fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a unit value.

fn deserialize_unit_struct<V>( self, _name: &'static str, visitor: V ) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a unit struct with a particular name.

fn deserialize_newtype_struct<V>( self, _name: &'static str, visitor: V ) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a newtype struct with a particular name.

fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a sequence of values.

fn deserialize_tuple<V>( self, _len: usize, visitor: V ) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a sequence of values and knows how many values there are without looking at the serialized data.

fn deserialize_tuple_struct<V>( self, _name: &'static str, _len: usize, _visitor: V ) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a tuple struct with a particular name and number of fields.

fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a map of key-value pairs.

fn deserialize_struct<V>( self, _name: &'static str, fields: &'static [&'static str], visitor: V ) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a struct with a particular name and fields.

fn deserialize_enum<V>( self, _name: &'static str, _variants: &'static [&'static str], visitor: V ) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an enum value with a particular name and possible variants.

fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting the name of a struct field or the discriminant of an enum variant.

fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Hint that the Deserialize type needs to deserialize a value whose type doesn’t matter because it is ignored.

fn deserialize_i128<V>( self, visitor: V ) -> Result<<V as Visitor<'de>>::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i128 value.

fn deserialize_u128<V>( self, visitor: V ) -> Result<<V as Visitor<'de>>::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an u128 value.

fn is_human_readable(&self) -> bool

Determine whether Deserialize implementations should expect to deserialize their human-readable form.

impl<'a, 'de> EnumAccess<'de> for &'a mut KeyValueDeserializer<'de>

type Error = ParseError

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

type Variant = &'a mut KeyValueDeserializer<'de>

The Visitor that will be used to deserialize the content of the enum variant.

fn variant_seed<V>( self, seed: V ) -> Result<(V::Value, Self::Variant), ParseError>

where V: DeserializeSeed<'de>,

variant is called to identify which variant to deserialize.

fn variant<V>(self) -> Result<(V, Self::Variant), Self::Error>

where V: Deserialize<'de>,

variant is called to identify which variant to deserialize.

impl<'de> From<&'de str> for KeyValueDeserializer<'de>

fn from(input: &'de str) -> Self

Converts to this type from the input type.

impl<'de> MapAccess<'de> for KeyValueDeserializer<'de>

type Error = ParseError

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

fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, ParseError>

where K: DeserializeSeed<'de>,

This returns Ok(Some(key)) for the next key in the map, or Ok(None) if there are no more remaining entries.

fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, ParseError>

where V: DeserializeSeed<'de>,

This returns a Ok(value) for the next value in the map.

fn next_entry_seed<K, V>( &mut self, kseed: K, vseed: V ) -> Result<Option<(<K as DeserializeSeed<'de>>::Value, <V as DeserializeSeed<'de>>::Value)>, Self::Error>

where K: DeserializeSeed<'de>, V: DeserializeSeed<'de>,

This returns Ok(Some((key, value))) for the next (key-value) pair in the map, or Ok(None) if there are no more remaining items.

fn next_key<K>(&mut self) -> Result<Option<K>, Self::Error>

where K: Deserialize<'de>,

This returns Ok(Some(key)) for the next key in the map, or Ok(None) if there are no more remaining entries.

fn next_value<V>(&mut self) -> Result<V, Self::Error>

where V: Deserialize<'de>,

This returns a Ok(value) for the next value in the map.

fn next_entry<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>

where K: Deserialize<'de>, V: Deserialize<'de>,

This returns Ok(Some((key, value))) for the next (key-value) pair in the map, or Ok(None) if there are no more remaining items.

fn size_hint(&self) -> Option<usize>

Returns the number of entries remaining in the map, if known.

impl<'de> SeqAccess<'de> for KeyValueDeserializer<'de>

type Error = ParseError

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

fn next_element_seed<T>( &mut self, seed: T ) -> Result<Option<T::Value>, ParseError>

where T: DeserializeSeed<'de>,

This returns Ok(Some(value)) for the next value in the sequence, or Ok(None) if there are no more remaining items.

fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>

where T: Deserialize<'de>,

This returns Ok(Some(value)) for the next value in the sequence, or Ok(None) if there are no more remaining items.

fn size_hint(&self) -> Option<usize>

Returns the number of elements remaining in the sequence, if known.

impl<'a, 'de> VariantAccess<'de> for &'a mut KeyValueDeserializer<'de>

type Error = ParseError

The error type that can be returned if some error occurs during deserialization. Must match the error type of our EnumAccess.

fn unit_variant(self) -> Result<(), ParseError>

Called when deserializing a variant with no values.

fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, ParseError>

where T: DeserializeSeed<'de>,

Called when deserializing a variant with a single value.

fn tuple_variant<V>( self, len: usize, visitor: V ) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Called when deserializing a tuple-like variant.

fn struct_variant<V>( self, _fields: &'static [&'static str], visitor: V ) -> Result<V::Value, ParseError>

where V: Visitor<'de>,

Called when deserializing a struct-like variant.

fn newtype_variant<T>(self) -> Result<T, Self::Error>

where T: Deserialize<'de>,

Called when deserializing a variant with a single value.