Struct chisel_json::paths::JsonPath

pub struct JsonPath<'a> { /* private fields */ }

Struct for creating and manipulating Json paths vaguely compatible with a subset of RFC 8259. Each instance of JsonPath comprises of multiple JsonPathComponents

Implementations

impl<'a> JsonPath<'a>

pub fn new_partial() -> Self

Create a new, partial (no root) JsonPath instance

pub fn new() -> Self

Create a new JsonPath instance with just a root component

pub fn is_empty(&self) -> bool

Is this an empty path?

pub fn is_partial(&self) -> bool

A partial path doesn’t have a JsonPathComponent::Root in the first position

pub fn as_string(&self) -> Cow<'a, str>

Render a string (Cow) representation of the path

pub fn push_str_selector(&mut self, name: &str)

Push a new JsonPathComponent::NameSelector based on a string slice. Note that no validation is carried out (as of yet) to check whether the name is actually valid and not full of crap

pub fn push_index_select(&mut self, index: usize)

Push a new JsonPathComponent::IndexSelector based on a given index

pub fn push_range_selector(&mut self, start: usize, end: usize)

Push a new JsonPathComponent::RangeSelector based on a given start and end index

pub fn push_wildcard_selector(&mut self)

Push a new JsonPathComponent::WildcardSelector

pub fn push(&mut self, component: JsonPathComponent<'a>)

Appends a new JsonPathComponent to the end of the path

pub fn pop(&mut self) -> Option<JsonPathComponent<'a>>

Pops the last JsonPathComponent from the end of the path (if it exists)

pub fn is_array_path(&self) -> bool

Checks whether a path points to an array element within the source JSON

pub fn len(&self) -> usize

Returns the number of JsonPathComponents within the path

pub fn matches_strict(&self, rhs: &JsonPath<'a>) -> bool

Determines whether a given JsonPath matches another given JsonPath strictly, in that wildcards do not match against ranges within the path, and each path must be identical to each other in the sense that all components match exactly

pub fn matches(&self, rhs: &JsonPath<'a>) -> bool

Determines whether a path matches a given path according to the following rules:

• A wildcard selector should match against an index selector in the same position
• Name selectors only match based on strict equality
• Indexed selectors match a range selector iff the index lies within the range supplied
• Range selectors only match strictly with other range selectors (hmmmm)

Trait Implementations

impl<'a> Add<&JsonPath<'a>> for JsonPath<'a>

fn add(self, rhs: &JsonPath<'a>) -> Self

Concatenate two JsonPath instances. Does some basic checking to ensure that you don’t try and concatenate two rooted paths, or concatenate a rooted path to a partial path

type Output = JsonPath<'a>

The resulting type after applying the + operator.

impl<'a> Debug for JsonPath<'a>

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

Formats the value using the given formatter.

impl<'a> Display for JsonPath<'a>

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

Formats the value using the given formatter.