Enum jmespath_community::Value

pub enum Value {
    Array(Vec<Value>),
    Boolean(bool),
    Null,
    Number(Number),
    String(String),
    Object(Map<String, Value>),
    Expression(AST),
}

Represents any valid value that is processed during evaluation of a JMESPath expression or used as an argument to a JMESPath Function.

Values are specified at runtime when calling the function. They must match the function’s signature.

Variants

Array(Vec<Value>)

Represents a valid JSON array.

Example

use jmespath_community as jmespath;
use jmespath::Value;
let value: Value = vec![1, 2, 3].into();
assert!(matches!(value, Value::Array(..)));

Boolean(bool)

Represents a valid JSON boolean.

Example

use jmespath_community as jmespath;
use jmespath::Value;
let value: Value = true.into();
assert!(matches!(value, Value::Boolean(true)));

Null

Represents a valid JSON null token.

Example

use jmespath_community as jmespath;
use jmespath::Value;
let value: Value = None.into();
assert!(matches!(value, Value::Null));

Number(Number)

Represents a valid JSON number.

Example

use jmespath_community as jmespath;
use jmespath::Value;
use jmespath::Number;
let value: Value = 42.into();
assert!(matches!(value, Value::Number(..)));

String(String)

Represents a valid JSON string.

Example

use jmespath_community as jmespath;
use jmespath::Value;
let value: Value = "text".into();
assert!(matches!(value, Value::String(..)));

Object(Map<String, Value>)

Represents a valid JSON object.

Example

use jmespath_community as jmespath;
use jmespath::{Map, Value};
use jmespath::map;
let value: Value = map!("foo" => "bar").into();
assert!(matches!(value, Value::Object(..)));

Expression(AST)

Represents a JMESPath expression.

Implementations

impl Value

pub fn from_f64(number: f64) -> Result<Self, Error>

pub fn map_from_json(value: &Value) -> Value

Converts a serde_json::Value to a Value.

Example

use jmespath_community as jmespath;
use jmespath::Value;
use serde_json::json;

let s = json!({"foo": "bar"});
let v = Value::map_from_json(&s);
assert!(matches!(v, Value::Object(..)));

pub fn from_json(text: &str) -> Result<Self, Error>

Creates a Value from a JSON representation.

Convenience function that uses serde_json to convert a JSON representation to a Value.

Example

use jmespath_community as jmespath;
use jmespath::Value;

let value = Value::from_json(r#"{"foo": "bar"}"#).unwrap();
assert!(value.is_object());

pub fn to_json(&self) -> String

Returns the JSON string representation for this Value.

Example

use jmespath_community as jmespath;
use jmespath::Value;

assert_eq!("null", Value::Null.to_json());
assert_eq!("\"text\"", Value::String("text".to_string()).to_json());

pub fn get_data_type(&self) -> DataType

Returns the corresponding DataType

Example

use jmespath_community as jmespath;
use jmespath::Value;
use jmespath::functions::DataType;

let arg = Value::from_f64(42.0).unwrap();
assert_eq!(DataType::Number, arg.get_data_type());

pub fn map_into<T>(vec: Vec<T>) -> Vec<Self>where T: Into<Value>,

Converts a Vec<T> to a Vec<Value>

Example

use jmespath_community as jmespath;
use jmespath::Value;
let vec: Vec<Value> = Value::map_into(vec![1, 2]);
 assert!(vec.iter().all(|x| matches!(x, Value::Number(..))));

pub fn as_array(&self) -> Option<&Vec<Value>>

Returns an Option<&Vec<Value>> of the corresponding type.

pub fn as_expref(&self) -> Option<&AST>

Returns an Option<&AST> of the corresponding type.

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

Returns an Option<&Number> of the corresponding type.

pub fn as_object(&self) -> Option<&Map<String, Value>>

Returns an Option<&Map<String, Value>> of the corresponding type.

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

Returns an Option<&str> of the corresponding type.

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

Returns an Option<bool> of the corresponding type.

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

Returns an Option<f64> of the corresponding type.

pub fn if_array(&self) -> Option<Value>

Returns Option<Value> if the Value is if_array .

pub fn if_object(&self) -> Option<Value>

Returns Option<Value> if the Value is if_object .

pub fn is_null(&self) -> bool

Returns true if the Value is the null value.

pub fn is_array(&self) -> bool

Returns true if the Value is a value from type Value::Array.

pub fn is_bool(&self) -> bool

Returns true if the Value is a value from type Value::Boolean.

pub fn is_number(&self) -> bool

Returns true if the Value is a value from type Value::Number.

pub fn is_object(&self) -> bool

Returns true if the Value is a value from type Value::Object.

pub fn is_str(&self) -> bool

Returns true if the Value is a value from type Value::String.

pub fn is_expression(&self) -> bool

Returns true if the Value is a value from type Value::Expression.

pub fn is_true(&self) -> bool

Returns true if the Value is the boolean true.

pub fn is_false(&self) -> bool

Returns false if the Value is the boolean false.

pub fn is_falsy(&self) -> bool

Returns true if the Value is either:

• the null value
• the boolean false
• the empty string ""
• an empty array []
• an empty object {}

pub fn is_truthy(&self) -> bool

Returns true if the Value is not a falsy value. This is the opposite to the Value::is_falsy() function.

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl Display for Value

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

Formats the value using the given formatter.

impl From<&String> for Value

fn from(v: &String) -> Self

Converts to this type from the input type.

impl From<&str> for Value

fn from(v: &str) -> Self

Converts to this type from the input type.

impl<V> From<BTreeMap<&str, V, Global>> for Valuewhere V: Into<Value>,

fn from(v: Map<&str, V>) -> Self

Converts to this type from the input type.

impl From<Number> for Value

fn from(number: Number) -> Self

Converts to this type from the input type.

impl From<Option<()>> for Value

fn from(_: Option<()>) -> Self

Converts to this type from the input type.

impl From<String> for Value

fn from(v: String) -> Self

Converts to this type from the input type.

impl<T> From<Vec<T, Global>> for Valuewhere T: Into<Value>,

fn from(v: Vec<T>) -> Self

Converts to this type from the input type.

impl From<bool> for Value

fn from(v: bool) -> Self

Converts to this type from the input type.

impl From<i16> for Value

fn from(v: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Value

fn from(v: i32) -> Self

Converts to this type from the input type.

impl From<i8> for Value

fn from(v: i8) -> Self

Converts to this type from the input type.

impl From<isize> for Value

fn from(v: isize) -> Self

Converts to this type from the input type.

impl From<u16> for Value

fn from(v: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Value

fn from(v: u32) -> Self

Converts to this type from the input type.

impl From<u8> for Value

fn from(v: u8) -> Self

Converts to this type from the input type.

impl From<usize> for Value

fn from(v: usize) -> Self

Converts to this type from the input type.

impl PartialEq<&str> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Option<()>> for Value

fn eq(&self, _: &Option<()>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<String> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for &str

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for Option<()>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for String

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for bool

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for f32

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for f64

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for i16

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for i32

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for i64

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for i8

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for isize

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for u16

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for u32

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for u64

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for u8

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for usize

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<bool> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<f32> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<f64> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<i16> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<i32> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<i64> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<i8> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<isize> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<u16> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<u32> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<u64> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<u8> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<usize> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Value

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Value