Struct fltrs::Query

pub struct Query<PR> { /* private fields */ }

The Query is an builder to configure the query(). It is possible, to extend the Operators in the modul: crate::operator.

Example

Create your own operator:

use fltrs::{value::Value, PathResolver, Predicate, Query, Result, query};

fn upper_eq<PR: PathResolver>(idx: usize, v: Value) -> Result<Predicate<PR>> {
    Ok(Box::new(
        move |pr| {
          if let Value::Text(t) = &v {
              return pr.value(idx).as_string().to_uppercase().eq(&t.to_uppercase());
          }
          false
        }
     ))
}

let query = Query::build()
             .operators(&[("upper_eq", upper_eq)])
             .query(r#" upper_eq "ab" "#)
             .unwrap();

let result: Vec<&str> = ["yz", "aB", "Ab", "xY"].into_iter().filter(query).collect();

assert_eq!(vec!["aB", "Ab"], result);

Create your own as [convert function] (for example: conversion of units):

use fltrs::{value::Value, PathResolver, Predicate, Query, Result, query};

let query = Query::build()
             .as_value_fn(&[("kbyte", |v| {
                    if let Value::Int(x) = v {
                        return Value::Int(x * 1024);
                    }
                    v
                  }
                )])
             .query(r#" > 1 as kbyte and < 6 as kbyte "#)
             .unwrap();

// list of bytes
let result: Vec<i32> = [100, 1025, 7000, 4001].into_iter().filter(query).collect();

assert_eq!(vec![1025, 4001], result);

Implementations

impl<PR: PathResolver + 'static> Query<PR>

pub fn build() -> Self

pub fn operators(self, ops: &[(&'static str, OperatorFn<PR>)]) -> Self

pub fn as_value_fn(
    self,
    fns: &[(&'static str, fn(val: Value) -> Value)]
) -> Self

pub fn query(&self, query: &str) -> Result<Predicate<PR>>