whereexpr 0.1.6

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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use super::numeric::u64::*;
use crate::Value;
use crate::types::*;
use crate::Error;
use crate::Operation;
use crate::ValueKind;
use super::numeric::*;

#[derive(Debug)]
pub(crate) struct DateTimeInsideRange {
    min: u64,
    max: u64,
}

impl DateTimeInsideRange {
    pub(crate) fn with_str_list(values: &[&str]) -> Result<Self, Error> {
        if values.len() != 2 {
            return Err(Error::ExpectingTwoValuesForRange(ValueKind::DateTime));
        }
        let min: u64 = DateTime::from_repr(values[0])?.into();
        let max: u64 = DateTime::from_repr(values[1])?.into();
        if min > max {
            return Err(Error::ExpectingMinToBeLessThanMax(ValueKind::DateTime));
        }
        Ok(Self { min, max })
    }
    pub(crate) fn with_value_list(values: &[Value<'_>]) -> Result<Self, Error>
    {
        if values.len() != 2 {
            return Err(Error::ExpectingTwoValuesForRange(ValueKind::DateTime));
        }
        let start = match values[0] {
            Value::DateTime(v) => v,
            _ => return Err(Error::ExpectingADifferentValueKind(values[0].kind(), ValueKind::DateTime)),
        };
        let end = match values[1] {
            Value::DateTime(v) => v,
            _ => return Err(Error::ExpectingADifferentValueKind(values[1].kind(), ValueKind::DateTime)),
        };
        if start > end {
            return Err(Error::ExpectingMinToBeLessThanMax(ValueKind::DateTime));
        }
        Ok(Self { min: start, max: end })
    }  
    pub(crate) fn evaluate(&self, value: u64) -> bool {
        value >= self.min && value <= self.max
    }
}

#[derive(Debug)]
pub(crate) enum DateTimePredicate {
    SmallerThanOrEqualTo(SmallerThanOrEqualTo),
    SmallerThan(SmallerThan),
    GreaterThanOrEqualTo(GreaterThanOrEqualTo),
    GreaterThan(GreaterThan),
    EqualTo(EqualTo),
    InsideRange(DateTimeInsideRange),
}

impl DateTimePredicate {
    #[inline(always)]
    pub(crate) fn evaluate(&self, value: u64) -> bool {
        match self {
            DateTimePredicate::SmallerThanOrEqualTo(predicate) => predicate.evaluate(value),
            DateTimePredicate::SmallerThan(predicate) => predicate.evaluate(value),
            DateTimePredicate::GreaterThanOrEqualTo(predicate) => predicate.evaluate(value),
            DateTimePredicate::GreaterThan(predicate) => predicate.evaluate(value),
            DateTimePredicate::EqualTo(predicate) => predicate.evaluate(value),
            DateTimePredicate::InsideRange(predicate) => predicate.evaluate(value),
        }
    }
    pub(crate) fn with_value(operation: Operation, value: u64) -> Result<Self, Error> {
        match operation {
            Operation::GreaterThan => Ok(DateTimePredicate::GreaterThan(GreaterThan::new(value))),
            Operation::GreaterThanOrEqual => Ok(DateTimePredicate::GreaterThanOrEqualTo(GreaterThanOrEqualTo::new(value))),
            Operation::LessThan => Ok(DateTimePredicate::SmallerThan(SmallerThan::new(value))),
            Operation::LessThanOrEqual => Ok(DateTimePredicate::SmallerThanOrEqualTo(SmallerThanOrEqualTo::new(value))),
            Operation::Is => Ok(DateTimePredicate::EqualTo(EqualTo::new(value))),
            _ => Err(Error::InvalidOperationForValue(operation, ValueKind::DateTime)),
        }
    }

    pub(crate) fn with_str(operation: Operation, value: &str) -> Result<Self, Error> {
        Self::with_value(operation, DateTime::from_repr(value)?.into())
    }

    pub(crate) fn with_str_list(operation: crate::Operation, values: &[&str]) -> Result<Self, Error> {
        match operation {
            crate::Operation::InRange => Ok(Self::InsideRange(DateTimeInsideRange::with_str_list(values)?)),
            _ => Err(Error::InvalidOperationForValue(operation, ValueKind::DateTime)),
        }
    }

    pub(crate) fn with_value_list(operation: crate::Operation, values: &[Value<'_>]) ->  Result<Self, Error> 
    {
        match operation {
            Operation::InRange => Ok(Self::InsideRange(DateTimeInsideRange::with_value_list(values)?)),
            _ => Err(Error::InvalidOperationForValue(operation, ValueKind::DateTime)),
        }
    }  
}