whereexpr 0.1.1

A fast, expressive rule-based filtering engine for Rust that evaluates boolean expressions over any data structure
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use crate::Error;
use crate::types::IntoValueKind;
use std::fmt::Debug;
use crate::Value;


macro_rules! CREATE_PREDICATE_ENUM {
    ($name:ident, $type:ty, $module:ident) => {
        #[derive(Debug)]
        pub(crate) enum $name {
            SmallerThanOrEqualTo(super::numeric::$module::SmallerThanOrEqualTo),
            SmallerThan(super::numeric::$module::SmallerThan),
            GreaterThanOrEqualTo(super::numeric::$module::GreaterThanOrEqualTo),
            GreaterThan(super::numeric::$module::GreaterThan),
            EqualTo(super::numeric::$module::EqualTo),
            InsideRange(super::numeric::$module::InsideRange),
            IsOneOf(super::list_search::ListSearch<$type>),
        }

        impl $name {
            #[inline(always)]
            pub(crate) fn evaluate(&self, value: $type) -> bool {
                match self {
                    Self::SmallerThanOrEqualTo(p) => p.evaluate(value),
                    Self::SmallerThan(p) => p.evaluate(value),
                    Self::GreaterThanOrEqualTo(p) => p.evaluate(value),
                    Self::GreaterThan(p) => p.evaluate(value),
                    Self::EqualTo(p) => p.evaluate(value),
                    Self::InsideRange(p) => p.evaluate(value),
                    Self::IsOneOf(p) => p.evaluate(value),
                }
            }

            pub(crate) fn with_value(operation: crate::Operation, value: $type) -> Result<Self, Error> {
                match operation {
                    crate::Operation::GreaterThan => Ok(Self::GreaterThan(super::numeric::$module::GreaterThan::new(value))),
                    crate::Operation::GreaterThanOrEqual => Ok(Self::GreaterThanOrEqualTo(super::numeric::$module::GreaterThanOrEqualTo::new(value))),
                    crate::Operation::LessThan => Ok(Self::SmallerThan(super::numeric::$module::SmallerThan::new(value))),
                    crate::Operation::LessThanOrEqual => Ok(Self::SmallerThanOrEqualTo(super::numeric::$module::SmallerThanOrEqualTo::new(value))),
                    crate::Operation::Is => Ok(Self::EqualTo(super::numeric::$module::EqualTo::new(value))),
                    _ => Err(Error::InvalidOperationForValue(operation, <$type>::VALUE_KIND)),
                }
            }
            pub(crate) fn with_str(operation: crate::Operation, value: &str) -> Result<Self, Error> {
                match value.parse::<$type>() {
                    Ok(value) => Self::with_value(operation, value),
                    Err(_) => Err(Error::FailToParseValue(value.to_string(), <$type>::VALUE_KIND)),
                }
            }

            pub(crate) fn with_str_list(operation: crate::Operation, values: &[&str]) -> Result<Self, Error> {
                match operation {
                    crate::Operation::InRange => Ok(Self::InsideRange(super::numeric::$module::InsideRange::with_str_list(values)?)),
                    crate::Operation::IsOneOf => Ok(Self::IsOneOf(super::list_search::ListSearch::with_str_list(values)?)),
                    _ => Err(Error::InvalidOperationForValue(operation, <$type>::VALUE_KIND)),
                }
            }      
            pub(crate) fn with_value_list(operation: crate::Operation, values: &[Value<'_>]) ->  Result<Self, Error> 
            {
                match operation {
                    crate::Operation::InRange => Ok(Self::InsideRange(super::numeric::$module::InsideRange::with_value_list(values)?)),
                    crate::Operation::IsOneOf => Ok(Self::IsOneOf(super::list_search::ListSearch::with_value_list(values)?)),
                    _ => Err(Error::InvalidOperationForValue(operation, <$type>::VALUE_KIND)),
                }
            }                    
        }
    };
}

CREATE_PREDICATE_ENUM!(I8Predicate,  i8,  i8);
CREATE_PREDICATE_ENUM!(I16Predicate, i16, i16);
CREATE_PREDICATE_ENUM!(I32Predicate, i32, i32);
CREATE_PREDICATE_ENUM!(I64Predicate, i64, i64);
CREATE_PREDICATE_ENUM!(U8Predicate,  u8,  u8);
CREATE_PREDICATE_ENUM!(U16Predicate, u16, u16);
CREATE_PREDICATE_ENUM!(U32Predicate, u32, u32);
CREATE_PREDICATE_ENUM!(U64Predicate, u64, u64);