Enum LazyValue 

pub enum LazyValue<'a> {
    Null,
    Raw(Raw<'a>),
    Array(Array<'a>),
    Object(Object<'a>),
    String(String<'a>),
    Number(Number),
    Boolean(bool),
}

Represents a lazy JSON value.

The initial value will always be Value::Raw until you call its mutating APIs.

Variants

Null

Represents a JSON null value.

Raw(Raw<'a>)

Represents an unparsed raw JSON value.

Array(Array<'a>)

Represents a JSON array.

Object(Object<'a>)

Represents a JSON object.

String(String<'a>)

Represents a JSON string.

Number(Number)

Represents a JSON number.

Boolean(bool)

Represents a JSON boolean.

Implementations

impl<'a> Value<'a>

pub fn as_raw(&'a self) -> Option<Raw<'a>>

Returns unparsed raw JSON if it is still in raw form, None otherwise.

pub fn as_null(&mut self) -> Option<()>

Returns () if it is a null, None otherwise.

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

Returns bool if it is a boolean, None otherwise.

pub fn as_array(&mut self) -> Option<&mut Array<'a>>

Returns a mutable reference to Array if it is an array, None otherwise.

pub fn into_array(self) -> Option<Array<'a>>

Returns Array if it is an array, None otherwise.

pub fn as_object(&mut self) -> Option<&mut Object<'a>>

Returns a mutable reference to Object if it is an object, None otherwise.

pub fn into_object(self) -> Option<Object<'a>>

Returns Object if it is an object, None otherwise.

pub fn as_number(&mut self) -> Option<Number>

Returns Number if it is a number, None otherwise.

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

Returns i64 if it is an integer and negative, None otherwise.

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

Returns i64 if it is an integer and positive, None otherwise.

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

Returns f64 if it is a floating point number or an integer that is too big, None otherwise.

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

Returns string slice if it is a string, None otherwise.

pub fn is_raw(&self) -> bool

Returns true if it is still a raw value, false otherwise.

pub fn is_str(&self) -> bool

Returns true if it is a string, false otherwise.

pub fn is_null(&self) -> bool

Returns true if it is a null, false otherwise.

pub fn is_bool(&self) -> bool

Returns true if it is a boolean, false otherwise.

pub fn is_array(&self) -> bool

Returns true if it is an array, false otherwise.

pub fn is_object(&self) -> bool

Returns true if it is an object, false otherwise.

pub fn is_number(&self) -> bool

Returns true if it is a number, false otherwise.

pub fn pointer<P>(&'a self, p: P) -> Option<Value<'a>>

where P: IntoIterator, P::Item: JsonPointer,

Looks up a value by the given path.

This is faster than its mutating APIs if you only need to get a particular value once as it doesn’t cache the values. If the path is empty, then the root value is returned. The returned value will generally be a raw value unless it is a string in which case it will return a borrowed string. Numbers, booleans and nulls are returned as is.

Example

use flexon::{LazyValue, jsonp};

let val: LazyValue = flexon::parse(r#"{"foo": ["bar", 123]}"#)?;

assert!(val.pointer(jsonp!["foo", 1]).unwrap().is_number());
assert!(val.pointer([0]).is_none());

Trait Implementations

impl Debug for Value<'_>

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

Formats the value using the given formatter.

impl<'a> Index<&str> for Value<'a>

type Output = Value<'a>

The returned type after indexing.

fn index(&self, _: &str) -> &Self::Output

Performs the indexing (container[index]) operation.

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

type Output = Value<'a>

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

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

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

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

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

impl<'a, S: Source<Volatility = NonVolatile>> ValueBuilder<'a, S> for Value<'a>

const LAZY: bool = true

Whether the value that it is building is lazy.

const CUSTOM_LITERAL: bool = false

Whether the value is to parse literals by itself.

type Error = Error

The error type used by this builder.

type Array = _Array

The array type used by this builder.

type Object = _Object<'a, S, Value<'a>>

The object type used by this builder.

type String = _String

The string type used by this builder.

fn literal(_: &[u8]) -> Result<Self, Self::Error>

Creates a value by the given byte slice.

fn integer(_: u64, _: bool) -> Self

Creates a value by the given integer value.

fn float(_: f64) -> Self

Creates a value by the given floating point value.

fn bool(_: bool) -> Self

Creates a value by the given boolean value.

fn null() -> Self

Creates a value in the context of null value in JSON.

fn raw(s: &'a [u8]) -> Self

Creates a value by the given raw JSON byte slice.

fn apply_span(&mut self, _: usize, _: usize)

Applies span information. The given offsets will be byte offsets.