Enum Kind 

#[non_exhaustive]
pub enum Kind {
    Null,
    Bool(bool),
    U64(u64),
    I64(i64),
    F32(f32),
    F64(f64),
    Char(char),
    Str(String),
    Lexical(String),
    Bytes(Bytes<'static>),
    Ext(ExtValue<'static>),
    Implicit(Implicit<'static>),
    Seq(Seq),
    Map(Map),
}

The data of a Value.

See Value for more information.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Null

Bool(bool)

U64(u64)

An unsigned integer.

I64(i64)

A signed integer.

Values created by this crate only use this for negative integers.

F32(f32)

A single precision float.

It keeps the precision for serialization (0.1f32 is written as 0.1), otherwise it behaves like the same value as F64: they compare equal and hash the same.

F64(f64)

A double precision float.

Char(char)

Str(String)

Lexical(String)

The lexical form of a value whose type the format cannot express.

This is created from Atom::Lexical, for instance for the keys of JSON objects. It’s serialized as lexical atom again, so types that parse lexical atoms (like numbers) can be deserialized from it. Otherwise it behaves like a string: it compares equal to and hashes like the same Str and the accessors for strings return it.

Bytes(Bytes<'static>)

Ext(ExtValue<'static>)

A value extending the data model.

Implicit(Implicit<'static>)

A value whose type the format inferred from its text.

This is created from Atom::Implicit, for instance for the plain scalars of YAML (42, 1.10, true or ~). It’s serialized as implicit atom again, so types that do not accept the value (like strings) can be deserialized from its text. Otherwise it behaves like its value: it compares equal to and hashes like the same value, the accessors (like as_f64) return it and as_str does not return the text.

Seq(Seq)

Map(Map)

Implementations

impl Kind

pub fn name(&self) -> &str

Returns the human readable name of the kind.

pub fn is_null(&self) -> bool

Returns true if this is null.

Extension values that fall back to null count as null.

pub fn as_bool(&self) -> Option<bool>

Returns the value of a bool.

pub fn as_u64(&self) -> Option<u64>

Returns the value of an integer if it fits into u64.

pub fn as_i64(&self) -> Option<i64>

Returns the value of an integer if it fits into i64.

pub fn as_u128(&self) -> Option<u128>

Returns the value of an integer if it fits into u128.

pub fn as_i128(&self) -> Option<i128>

Returns the value of an integer if it fits into i128.

pub fn as_f64(&self) -> Option<f64>

Returns the value of a number as f64.

Integers are converted, which can lose precision.

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

Returns the value of a char.

pub fn as_str(&self) -> Option<&str>

Returns the value of a string.

For extension values this returns the fallback if it’s a string that borrows from the value.

pub fn as_bytes(&self) -> Option<&[u8]>

Returns the data of bytes.

pub fn as_seq(&self) -> Option<&Seq>

Returns the sequence.

pub fn as_seq_mut(&mut self) -> Option<&mut Seq>

Returns the sequence mutably.

pub fn as_map(&self) -> Option<&Map>

Returns the map.

pub fn as_map_mut(&mut self) -> Option<&mut Map>

Returns the map mutably.

pub fn as_ext(&self) -> Option<&ExtValue<'static>>

Returns the extension value.

pub fn downcast_ext<T: Extension>(&self) -> Option<&T>

Returns the extension value if it’s of type T.

For extensions that borrow, use downcast_ext_value.

pub fn downcast_ext_value<K: BorrowedExtension>(&self) -> Option<&K::Value<'_>>

Returns the extension value if it’s of the extension with the key K.

See BorrowedExtension.

use deser::ext::Number;
use deser_value::Value;

let value: Value =
    deser_json::from_str("0.10000000000000000001").unwrap();
let number = value.downcast_ext_value::<Number>().unwrap();
assert_eq!(number.as_str(), "0.10000000000000000001");

pub fn is_str(&self) -> bool

Returns true if this is a string.

This is also true for lexical values.

pub fn is_lexical(&self) -> bool

Returns true if this is a lexical value.

pub fn is_seq(&self) -> bool

Returns true if this is a sequence.

pub fn is_map(&self) -> bool

Returns true if this is a map.

pub fn get<I: ValueIndex>(&self, index: I) -> Option<&Value>

Looks up a value in a sequence (by index) or a map (by key).

use deser_value::value;

let value = value!({"items": [1, 2], 42: "answer"});
assert_eq!(value.get("items").and_then(|x| x.get(1)), Some(&value!(2)));
assert_eq!(value.get(&value!(42)), Some(&value!("answer")));
assert_eq!(value.get("missing"), None);

pub fn get_mut<I: ValueIndex>(&mut self, index: I) -> Option<&mut Value>

Looks up a value in a sequence (by index) or a map (by key) mutably.

Trait Implementations

impl Clone for Kind

fn clone(&self) -> Kind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Kind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Kind

impl From<Kind> for Value

fn from(kind: Kind) -> Value

Converts to this type from the input type.

impl Hash for Kind

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Kind

fn eq(&self, other: &Kind) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Kind

fn serialize<'a>(this: &'a Self, state: &mut State) -> Result<Emit<'a>, Error>

Serializes the value.

fn container_shape(value: &Self) -> ContainerShape

Returns the shape of the value if it’s a map or sequence.

fn is_optional(value: &Self) -> bool

Checks if the value represents an optional value.

fn finish(value: &T, state: &mut State) -> Result<(), Error>

Invoked after the serialization finished.

fn describe(value: &T, d: &mut dyn Describe)

Describes the Rust shape of the value.