Struct jlens::Node

pub struct Node { /* fields omitted */ }

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Node

impl Selector for Node

fn select<'a, 'b, F>(&self, input: &JsonPath<'a, 'b>, f: F) where
    F: for<'c> FnMut(&JsonPath<'a, 'c>), 

Select matching nodes

fn boolean(self) -> BooleanSel<Self>

Select current node if it is a Json::Boolean

fn uint64(self) -> U64Sel<Self>

Select current node if it is a Json::U64

fn int64(self) -> I64Sel<Self>

Select current node if it is a Json::I64

fn float64(self) -> F64Sel<Self>

Select current node if it is a Json::F64

fn string(self) -> StringSel<Self>

Select current node if it is a Json::String

fn object(self) -> ObjectSel<Self>

Select current node if it is a Json::Object

fn list(self) -> ListSel<Self>

Select current node if it is a Json::Array

fn null(self) -> NullSel<Self>

Select current node if it is a Json::Null

fn at(self, index: usize) -> At<Self>

Select list element

fn key(self, name: &str) -> Key<Self>

Select object value for key

fn child(self) -> Child<Self>

Select children of current node

fn parent(self) -> Parent<Self>

Select parent of current node

fn descend(self) -> Descend<Self>

Select descendents of current node

fn ascend(self) -> Ascend<Self>

Select ancestors of current node

fn wherein<T: Selector>(self, filter: T) -> Wherein<Self, T>

Select current node based on filter

fn union<T1: Selector, T2: Selector>(
    self,
    left: T1,
    right: T2
) -> Union<Self, T1, T2>

Select union of two selectors

fn intersect<T1: Selector, T2: Selector>(
    self,
    left: T1,
    right: T2
) -> Intersect<Self, T1, T2>

Select intersection of two selectors

fn diff<T1: Selector, T2: Selector>(
    self,
    left: T1,
    right: T2
) -> Diff<Self, T1, T2>

Select symmetric difference of two selectors

fn and<T1: Selector, T2: Selector>(
    self,
    left: T1,
    right: T2
) -> AndSel<Self, T1, T2>

Select logical-and of two selectors

fn or<T1: Selector, T2: Selector>(
    self,
    left: T1,
    right: T2
) -> OrSel<Self, T1, T2>

Select logical-or of two selectors