whereexpr 0.1.5

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

use crate::Error;
use crate::Value;
use crate::types::IntoValueKind;

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),
        }

        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),
                }
            }

            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)?)),
                    _ => 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)?)),
                    _ => Err(Error::InvalidOperationForValue(operation, <$type>::VALUE_KIND)),
                }
            }              
        }
    };
}

CREATE_PREDICATE_ENUM!(F32Predicate, f32, f32);
CREATE_PREDICATE_ENUM!(F64Predicate, f64, f64);