Enum jsonpath_rust::JsonPath

pub enum JsonPath {
    Root,
    Field(String),
    Chain(Vec<JsonPath>),
    Descent(String),
    DescentW,
    Index(JsonPathIndex),
    Current(Box<JsonPath>),
    Wildcard,
    Empty,
    Fn(Function),
}

The basic structures for parsing json paths. The common logic of the structures pursues to correspond the internal parsing structure.

usually it’s created by using FromStr or TryFrom<&str>

Variants

Root

The $ operator

Field(String)

Field represents key

Chain(Vec<JsonPath>)

The whole chain of the path.

Descent(String)

The .. operator

DescentW

The ..* operator

Index(JsonPathIndex)

The indexes for array

Current(Box<JsonPath>)

The @ operator

Wildcard

The * operator

Empty

The item uses to define the unresolved state

Fn(Function)

Functions that can calculate some expressions

Implementations

impl JsonPath

pub fn find_slice<'a>( &'a self, json: &'a Value, ) -> Vec<JsonPathValue<'a, Value>>

finds a slice of data in the set json. The result is a vector of references to the incoming structure.

In case, if there is no match Self::find_slice will return vec!<JsonPathValue::NoValue>.

Example

use jsonpath_rust::{JsonPath, JsonPathValue};
use serde_json::json;

let data = json!({"first":{"second":[{"active":1},{"passive":1}]}});
let path = JsonPath::try_from("$.first.second[?(@.active)]").unwrap();
let slice_of_data = path.find_slice(&data);

let expected_value = json!({"active":1});
let expected_path = "$.['first'].['second'][0]".to_string();

assert_eq!(
    slice_of_data,
    vec![JsonPathValue::Slice(&expected_value, expected_path)]
);

pub fn find_slice_ptr<'a>(&'a self, json: &'a Value) -> Vec<JsonPtr<'a, Value>>

like Self::find_slice but returns a vector of JsonPtr, which has no JsonPathValue::NoValue. if there is no match, it will return an empty vector

pub fn find(&self, json: &Value) -> Value

finds a slice of data and wrap it with Value::Array by cloning the data. Returns either an array of elements or Json::Null if the match is incorrect.

In case, if there is no match find will return json!(null).

Example

use jsonpath_rust::{JsonPath, JsonPathValue};
use serde_json::{Value, json};

let data = json!({"first":{"second":[{"active":1},{"passive":1}]}});
let path = JsonPath::try_from("$.first.second[?(@.active)]").unwrap();
let cloned_data = path.find(&data);

assert_eq!(cloned_data, Value::Array(vec![json!({"active":1})]));

pub fn find_as_path(&self, json: &Value) -> Value

finds a path describing the value, instead of the value itself. If the values has been obtained by moving the data out of the initial json the path is absent.

** If the value has been modified during the search, there is no way to find a path of a new value. It can happen if we try to find a length() of array, for in stance.**

Example

use jsonpath_rust::{JsonPath, JsonPathValue};
use serde_json::{Value, json};

let data = json!({"first":{"second":[{"active":1},{"passive":1}]}});
let path = JsonPath::try_from("$.first.second[?(@.active)]").unwrap();
let slice_of_data: Value = path.find_as_path(&data);

let expected_path = "$.['first'].['second'][0]".to_string();
assert_eq!(slice_of_data, Value::Array(vec![Value::String(expected_path)]));

Trait Implementations

impl Clone for JsonPath

fn clone(&self) -> JsonPath

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for JsonPath

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

Formats the value using the given formatter.

impl FromStr for JsonPath

fn from_str(value: &str) -> Result<Self, Self::Err>

Parses a string into a JsonPath.

Errors

Returns a variant of JsonPathParserError if the parsing operation failed.

type Err = JsonPathParserError

The associated error which can be returned from parsing.

impl PartialEq for JsonPath

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 TryFrom<&str> for JsonPath

fn try_from(value: &str) -> Result<Self, Self::Error>

Parses a string into a JsonPath.

Errors

Returns a variant of JsonPathParserError if the parsing operation failed.

type Error = JsonPathParserError

The type returned in the event of a conversion error.