Enum Value 

pub enum Value<'s> {
    None,
    Str(&'s str),
    Int(i64),
    Float(f64),
    Bool(bool),
    List(Vec<Value<'s>>),
    Dict(HashMap<&'s str, Value<'s>>),
}

Value type returned by Dent.

Represents a value in Dent, which can be a string, integer, float, boolean, list or dictionary.

Values are stored as references to the original string, so they are only valid as long as the original string is valid. For values returned by parsing files, whether by Dent::parse_file or the @import function, they should be valid for the lifetime of the parser object.

Accessing values

Values can be accessed using the [] operator, which takes either a string or an integer. If the value is a dictionary, the string will be used as a key. If the value is a list, the integer will be used as an index.

If a dictionary key or list index is not found, the value Value::None will be returned during immutable access.

During mutable access, if a dictionary key is not found, a new entry will be created with the value Value::None. If a list index is not found, the program will panic.

Examples

use dent_parse::{Dent, Value};

let parser = Dent::default();
let value = parser.parse("{ foo: 1 }").unwrap();
assert_eq!(value["foo"], Value::Int(1));

use dent_parse::{Dent, Value};

let parser = Dent::default();
let value = parser.parse("[ 1 2 3 ]").unwrap();
assert_eq!(value[1], Value::Int(2));

Variants

None

Str(&'s str)

Int(i64)

Float(f64)

Bool(bool)

List(Vec<Value<'s>>)

Dict(HashMap<&'s str, Value<'s>>)

Implementations

impl<'s> Value<'s>

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

Returns the underlying string value, if it is one

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

Returns the underlying integer value, if it is one

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

Returns the underlying float value, if it is one

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

Returns the underlying boolean value, if it is one

pub fn as_list(&self) -> Option<&Vec<Value<'s>>>

Returns the underlying list value, if it is one

pub fn as_dict(&self) -> Option<&HashMap<&'s str, Value<'s>>>

Returns the underlying dictionary value, if it is one

pub fn is_none(&self) -> bool

Returns true if the value is None

pub fn is_str(&self) -> bool

Returns true if the value is a string

pub fn is_int(&self) -> bool

Returns true if the value is an integer

pub fn is_float(&self) -> bool

Returns true if the value is a float

pub fn is_bool(&self) -> bool

Returns true if the value is a boolean

pub fn is_list(&self) -> bool

Returns true if the value is a list

pub fn is_dict(&self) -> bool

Returns true if the value is a dictionary

pub fn len(&self) -> Option<usize>

Returns the length of the value, if it is a list or dictionary

pub fn is_empty(&self) -> bool

Returns true if the value is empty, if it is a list or dictionary

Trait Implementations

impl<'s> Clone for Value<'s>

fn clone(&self) -> Value<'s>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'s> Debug for Value<'s>

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

Formats the value using the given formatter.

impl<'s> Display for Value<'s>

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

Formats the value using the given formatter.

impl<'i, 's> Index<&'i str> for Value<'s>

type Output = Value<'s>

The returned type after indexing.

fn index(&self, key: &'i str) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'s> Index<usize> for Value<'s>

type Output = Value<'s>

The returned type after indexing.

fn index(&self, key: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'s> IndexMut<&'s str> for Value<'s>

fn index_mut(&mut self, key: &'s str) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'s> IndexMut<usize> for Value<'s>

fn index_mut(&mut self, key: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'s> PartialEq for Value<'s>

fn eq(&self, other: &Value<'s>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'s> StructuralPartialEq for Value<'s>