Struct Value

pub struct Value<'tape, 'input>(/* private fields */)
where
    'input: 'tape;

Wrapper around the tape that allows interaction via a Value-like API.

Implementations

impl<'tape, 'input> Value<'tape, 'input>

pub fn is_array(&self) -> bool

returns true if the current value can be represented as an array

pub fn is_object(&self) -> bool

returns true if the current value can be represented as an object

impl<'tape, 'input> Value<'tape, 'input>

pub fn try_get<Q>( &self, k: &Q, ) -> Result<Option<Value<'tape, 'input>>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get a value based on a key, returns a TryTypeError if the current Value isn’t an Object, returns None if the key isn’t in the object

Errors

if the value is not an object

impl<'tape, 'input> Value<'tape, 'input>

where 'input: 'tape,

pub fn try_get_idx( &self, i: usize, ) -> Result<Option<Value<'tape, 'input>>, TryTypeError>

Tries to get a value based on n index, returns a type error if the current value isn’t an Array, returns None if the index is out of bounds

Errors

if the requested type doesn’t match the actual type or the value is not an object

impl<'tape, 'input> Value<'tape, 'input>

where 'input: 'tape,

pub fn as_array(&self) -> Option<Array<'tape, 'input>>

Tries to represent the value as an array and returns a reference to it

pub fn as_object(&self) -> Option<Object<'tape, 'input>>

Tries to represent the value as an array and returns a reference to it

impl<'tape, 'input> Value<'tape, 'input>

pub fn try_as_array(&self) -> Result<Array<'tape, 'input>, TryTypeError>

Tries to represent the value as an array and returns a reference to it

Errors

if the requested type doesn’t match the actual type

pub fn try_as_object(&self) -> Result<Object<'tape, 'input>, TryTypeError>

Tries to represent the value as an object and returns a reference to it

Errors

if the requested type doesn’t match the actual type

impl<'tape, 'input> Value<'tape, 'input>

pub fn get<Q>(&self, k: &Q) -> Option<Value<'tape, 'input>>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Gets a ref to a value based on a key, returns None if the current Value isn’t an Object or doesn’t contain the key it was asked for.

pub fn contains_key(&self, k: &str) -> bool

Checks if a Value contains a given key. This will return flase if Value isn’t an object

impl<'tape, 'input> Value<'tape, 'input>

pub fn get_idx(&self, i: usize) -> Option<Value<'tape, 'input>>

Gets a ref to a value based on n index, returns None if the current Value isn’t an Array or doesn’t contain the index it was asked for.

impl<'tape, 'input> Value<'tape, 'input>

pub fn get_array<Q>(&self, k: &Q) -> Option<Array<'tape, 'input>>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a array

pub fn get_object<Q>(&self, k: &Q) -> Option<Object<'tape, 'input>>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a object

impl<'tape, 'input> Value<'tape, 'input>

pub fn try_get_array<Q>( &self, k: &Q, ) -> Result<Option<Array<'tape, 'input>>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as an array, returns an error if it isn’t a array

Errors

if the requested type doesn’t match the actual type or the value is not an object

pub fn try_get_object<Q>( &self, k: &Q, ) -> Result<Option<Object<'tape, 'input>>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as an object, returns an error if it isn’t an object

Errors

if the requested type doesn’t match the actual type or the value is not an object

impl Value<'static, 'static>

pub const NULL: Value<'static, 'static> = _

A static null value

pub const fn null() -> Self

Creates tape value representing a null value

Trait Implementations

impl<'tape, 'input> Clone for Value<'tape, 'input>

where 'input: 'tape,

fn clone(&self) -> Value<'tape, 'input>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tape, 'input> Debug for Value<'tape, 'input>

where 'input: 'tape,

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

Formats the value using the given formatter.

impl<'tape, 'input, T> PartialEq<&T> for Value<'tape, 'input>

where Value<'tape, 'input>: PartialEq<T>,

fn eq(&self, other: &&T) -> 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<'tape, 'input> PartialEq<&str> for Value<'tape, 'input>

fn eq(&self, other: &&str) -> 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<'tape, 'input> PartialEq<()> for Value<'tape, 'input>

fn eq(&self, _other: &()) -> 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<'tape, 'input, K, T, S> PartialEq<HashMap<K, T, S>> for Value<'tape, 'input>

where K: Borrow<str> + Hash + Eq, for<'i> T: PartialEq<Value<'i, 'input>>, S: BuildHasher,

fn eq(&self, other: &HashMap<K, T, 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<'tape, 'input> PartialEq<String> for Value<'tape, 'input>

fn eq(&self, other: &String) -> 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<'tape, 'input> PartialEq<bool> for Value<'tape, 'input>

fn eq(&self, other: &bool) -> 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<'tape, 'input> PartialEq<f32> for Value<'tape, 'input>

fn eq(&self, other: &f32) -> 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<'tape, 'input> PartialEq<f64> for Value<'tape, 'input>

fn eq(&self, other: &f64) -> 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<'tape, 'input> PartialEq<i128> for Value<'tape, 'input>

fn eq(&self, other: &i128) -> 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<'tape, 'input> PartialEq<i16> for Value<'tape, 'input>

fn eq(&self, other: &i16) -> 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<'tape, 'input> PartialEq<i32> for Value<'tape, 'input>

fn eq(&self, other: &i32) -> 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<'tape, 'input> PartialEq<i64> for Value<'tape, 'input>

fn eq(&self, other: &i64) -> 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<'tape, 'input> PartialEq<i8> for Value<'tape, 'input>

fn eq(&self, other: &i8) -> 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<'tape, 'input> PartialEq<str> for Value<'tape, 'input>

fn eq(&self, other: &str) -> 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<'tape, 'input> PartialEq<u128> for Value<'tape, 'input>

fn eq(&self, other: &u128) -> 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<'tape, 'input> PartialEq<u16> for Value<'tape, 'input>

fn eq(&self, other: &u16) -> 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<'tape, 'input> PartialEq<u32> for Value<'tape, 'input>

fn eq(&self, other: &u32) -> 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<'tape, 'input> PartialEq<u64> for Value<'tape, 'input>

fn eq(&self, other: &u64) -> 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<'tape, 'input> PartialEq<u8> for Value<'tape, 'input>

fn eq(&self, other: &u8) -> 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<'tape, 'input> PartialEq<usize> for Value<'tape, 'input>

fn eq(&self, other: &usize) -> 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<'tape, 'input> PartialEq for Value<'tape, 'input>

fn eq(&self, other: &Self) -> 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<'tape, 'input> TypedValue for Value<'tape, 'input>

fn value_type(&self) -> ValueType

Gets the type of the current value

impl<'tape, 'input> ValueAsScalar for Value<'tape, 'input>

where 'input: 'tape,

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

Tries to represent the value as a ‘null’;

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

Tries to represent the value as a bool

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

Tries to represent the value as an i64

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

Tries to represent the value as an u64

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

Tries to represent the value as a f64

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

Tries to represent the value as a &str

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

Tries to represent the value as an i128

fn as_i32(&self) -> Option<i32>

Tries to represent the value as an i32

fn as_i16(&self) -> Option<i16>

Tries to represent the value as an i16

fn as_i8(&self) -> Option<i8>

Tries to represent the value as an i8

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

Tries to represent the value as an u128

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

Tries to represent the value as an usize

fn as_u32(&self) -> Option<u32>

Tries to represent the value as an u32

fn as_u16(&self) -> Option<u16>

Tries to represent the value as an u16

fn as_u8(&self) -> Option<u8>

Tries to represent the value as an u8

fn as_f32(&self) -> Option<f32>

Tries to represent the value as a f32

fn cast_f64(&self) -> Option<f64>

Casts the current value to a f64 if possible, this will turn integer values into floats.

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

Tries to represent the value as a Char

impl<'tape, 'input> ValueIntoArray for Value<'tape, 'input>

type Array = Array<'tape, 'input>

The type for Arrays

fn into_array(self) -> Option<Self::Array>

Tries to turn the value into it’s array representation

impl<'tape, 'input> ValueIntoObject for Value<'tape, 'input>

type Object = Object<'tape, 'input>

The type for Objects

fn into_object(self) -> Option<Self::Object>

Tries to turn the value into it’s object representation

impl<'tape, 'input> ValueIntoString for Value<'tape, 'input>

type String = &'input str

The type for Strings

fn into_string(self) -> Option<&'input str>

Tries to turn the value into it’s string representation

impl<'tape, 'input> ValueObjectAccessAsScalar for Value<'tape, 'input>

where 'input: 'tape,

type Key = str

The type for Objects

fn get_bool<Q>(&self, k: &Q) -> Option<bool>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a bool

fn get_i128<Q>(&self, k: &Q) -> Option<i128>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a i128

fn get_i64<Q>(&self, k: &Q) -> Option<i64>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a i64

fn get_i32<Q>(&self, k: &Q) -> Option<i32>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a i32

fn get_i16<Q>(&self, k: &Q) -> Option<i16>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a i16

fn get_i8<Q>(&self, k: &Q) -> Option<i8>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a i8

fn get_u128<Q>(&self, k: &Q) -> Option<u128>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a u128

fn get_u64<Q>(&self, k: &Q) -> Option<u64>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a u64

fn get_usize<Q>(&self, k: &Q) -> Option<usize>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a usize

fn get_u32<Q>(&self, k: &Q) -> Option<u32>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a u32

fn get_u16<Q>(&self, k: &Q) -> Option<u16>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a u16

fn get_u8<Q>(&self, k: &Q) -> Option<u8>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a u8

fn get_f64<Q>(&self, k: &Q) -> Option<f64>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a f64

fn get_f32<Q>(&self, k: &Q) -> Option<f32>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a f32

fn get_str<Q>(&self, k: &Q) -> Option<&'input str>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a str

impl<'tape, 'input> ValueObjectAccessTryAsScalar for Value<'tape, 'input>

type Key = str

The type for Objects

fn try_get_bool<Q>(&self, k: &Q) -> Result<Option<bool>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a bool, returns an error if it isn’t bool

fn try_get_i128<Q>(&self, k: &Q) -> Result<Option<i128>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a i128, returns an error if it isn’t i128

fn try_get_i64<Q>(&self, k: &Q) -> Result<Option<i64>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a i64, returns an error if it isn’t a i64

fn try_get_i32<Q>(&self, k: &Q) -> Result<Option<i32>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a i32, returns an error if it isn’t a i32

fn try_get_i16<Q>(&self, k: &Q) -> Result<Option<i16>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a i16, returns an error if it isn’t a i16

fn try_get_i8<Q>(&self, k: &Q) -> Result<Option<i8>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a i8, returns an error if it isn’t a i8

fn try_get_u128<Q>(&self, k: &Q) -> Result<Option<u128>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a u128, returns an error if it isn’t a u128

fn try_get_u64<Q>(&self, k: &Q) -> Result<Option<u64>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a u64, returns an error if it isn’t a u64

fn try_get_usize<Q>(&self, k: &Q) -> Result<Option<usize>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a usize, returns an error if it isn’t a usize

fn try_get_u32<Q>(&self, k: &Q) -> Result<Option<u32>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a u32, returns an error if it isn’t a u32

fn try_get_u16<Q>(&self, k: &Q) -> Result<Option<u16>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a u16, returns an error if it isn’t a u16

fn try_get_u8<Q>(&self, k: &Q) -> Result<Option<u8>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a u8, returns an error if it isn’t a u8

fn try_get_f64<Q>(&self, k: &Q) -> Result<Option<f64>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a f64, returns an error if it isn’t a f64

fn try_get_f32<Q>(&self, k: &Q) -> Result<Option<f32>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a f32, returns an error if it isn’t a f32

fn try_get_str<Q>(&self, k: &Q) -> Result<Option<&str>, TryTypeError>

where str: Borrow<Q> + Hash + Eq, Q: ?Sized + Hash + Eq + Ord,

Tries to get an element of an object as a str, returns an error if it isn’t a str

impl<'tape, 'input> Writable for Value<'tape, 'input>

fn encode(&self) -> String

Encodes the value into it’s JSON representation as a string

fn encode_pp(&self) -> String

Encodes the value into it’s JSON representation as a string (pretty printed)

fn write<'writer, W>(&self, w: &mut W) -> Result<()>

where W: 'writer + Write,

Encodes the value into it’s JSON representation into a Writer

fn write_pp<'writer, W>(&self, w: &mut W) -> Result<()>

where W: 'writer + Write,

Encodes the value into it’s JSON representation into a Writer, pretty printed

impl<'tape, 'input> Copy for Value<'tape, 'input>

where 'input: 'tape,