Struct JsonPathSelectorsBuilder

pub struct JsonPathSelectorsBuilder { /* private fields */ }

Builder for a Selectors collection used by the JsonPathQueryBuilder to create multiple Selector instances within a Segment.

Implementations

impl JsonPathSelectorsBuilder

pub fn name<S: Into<JsonString>>(&mut self, name: S) -> &mut Self

Add a name selector with a given name string to the collection.

Examples

let mut builder = JsonPathQueryBuilder::new();
builder.child(|x| x.name("book").name("journal"));
let result = builder.into_query();
assert_eq!(result.segments().len(), 1);
let segment = &result.segments()[0];
assert_eq!(segment.selectors().as_slice(), &[
    Selector::Name(JsonString::new("book")),
    Selector::Name(JsonString::new("journal")),
]);

pub fn index<N: Into<JsonInt>>(&mut self, idx: N) -> &mut Self

Add an index selector based on a given JSON integer.

The result is a Selector::Index with an Index::FromStart if idx converts to a non-negative JsonInt, and Index::FromEnd otherwise.

Examples

let mut builder = JsonPathQueryBuilder::new();
builder.child(|x| x.index(10).index(-20));
let result = builder.into_query();
assert_eq!(result.segments().len(), 1);
let segment = &result.segments()[0];
assert_eq!(segment.selectors().as_slice(), &[
    Selector::Index(Index::FromStart(JsonUInt::from(10))),
    Selector::Index(Index::FromEnd(JsonNonZeroUInt::try_from(20).unwrap())),
]);

pub fn slice<F>(&mut self, slice_builder: F) -> &mut Self

where F: FnOnce(&mut SliceBuilder) -> &mut SliceBuilder,

Add a slice selector based on a given start, end, and step integers.

The result is a Selector::Slice with given start, end, and step.

Examples

let mut builder = JsonPathQueryBuilder::new();
builder.child(|x| x
    .slice(|s| s.with_start(10).with_end(-20).with_step(5))
    .slice(|s| s.with_start(-20).with_step(-30)));
let result = builder.into_query();

assert_eq!(result.segments().len(), 1);
let segment = &result.segments()[0];
let selectors = segment.selectors().as_slice();
match (&selectors[0], &selectors[1]) {
    (Selector::Slice(s1), Selector::Slice(s2)) => {
        assert_eq!(s1.start(), Index::FromStart(10.into()));
        assert_eq!(s1.end(), Some(Index::FromEnd(JsonNonZeroUInt::try_from(20).unwrap())));
        assert_eq!(s1.step(), Step::Forward(5.into()));
        assert_eq!(s2.start(), Index::FromEnd(JsonNonZeroUInt::try_from(20).unwrap()));
        assert_eq!(s2.end(), None);
        assert_eq!(s2.step(), Step::Backward(JsonNonZeroUInt::try_from(30).unwrap()));
    }
    _ => unreachable!()
}

pub fn wildcard(&mut self) -> &mut Self

Add a wildcard selector.

let mut builder = JsonPathQueryBuilder::new();
builder.child(|x| {
    x.filter(|x| {
        x.comparison(|x| {
            x.query_relative(|x| x.name("price"))
             .less_than()
             .literal(JsonInt::from(10))
        })
    })
});
let result = builder.into_query();
assert_eq!(result.segments().len(), 1);
let segment = &result.segments()[0];
assert_eq!(segment.selectors().len(), 1);
let selector = segment.selectors().first();

let Selector::Filter(LogicalExpr::Comparison(expr)) = selector else {
    panic!("expected comparison filter")
};
let Comparable::RelativeSingularQuery(lhs) = expr.lhs() else {
    panic!("expected lhs to be a relative singular query")
};
let lhs_segments: Vec<_> = lhs.segments().collect();
assert_eq!(&lhs_segments, &[
    &SingularSegment::Name(JsonString::new("price"))
]);
assert_eq!(expr.op(), ComparisonOp::LessThan);
assert_eq!(expr.rhs(), &Comparable::Literal(JsonInt::from(10).into()));

pub fn filter<F>(&mut self, filter_builder: F) -> &mut Self

where F: FnOnce(EmptyLogicalExprBuilder) -> LogicalExprBuilder,

Add a filter selector.