greynet 0.11.0

High performance rule and constraint satisfaction engine
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

//common_ops.rs
use super::*;
use std::any::Any;
use crate::prelude::Rc;
use crate::tuple::ZeroCopyFacts;
use crate::nodes::ZeroCopyPredicate;
use crate::nodes::ZeroCopyKeyFn;

/// Create a key function that extracts from the first fact's field
pub fn first_fact_field_key<T, F, K>(field_extractor: F) -> ZeroCopyKeyFn 
where
    T: GreynetFact,
    F: Fn(&T) -> K + 'static,
    K: std::hash::Hash + 'static,
{
    Rc::new(move |tuple: &dyn ZeroCopyFacts| {
        tuple.first_fact()
            .and_then(|fact| fact.as_any().downcast_ref::<T>())
            .map(|typed_fact| {
                let mut hasher = std::collections::hash_map::DefaultHasher::new();
                std::hash::Hash::hash(&field_extractor(typed_fact), &mut hasher);
                std::hash::Hasher::finish(&hasher)
            })
            .unwrap_or(0)
    })
}

/// Create a predicate that checks a field in the first fact
pub fn first_fact_field_predicate<T, F>(field_check: F) -> ZeroCopyPredicate
where
    T: GreynetFact,
    F: Fn(&T) -> bool + 'static,
{
    Rc::new(move |tuple: &dyn ZeroCopyFacts| {
        tuple.first_fact()
            .and_then(|fact| fact.as_any().downcast_ref::<T>())
            .map(|typed_fact| field_check(typed_fact))
            .unwrap_or(false)
    })
}

/// Create a key function for composite keys from multiple facts
pub fn composite_key_fn(indices: Vec<usize>) -> ZeroCopyKeyFn {
    Rc::new(move |tuple: &dyn ZeroCopyFacts| {
        let mut hasher = std::collections::hash_map::DefaultHasher::new();
        for &index in &indices {
            if let Some(fact) = tuple.get_fact_ref(index) {
                std::hash::Hash::hash(&fact.hash_fact(), &mut hasher);
            }
        }
        std::hash::Hasher::finish(&hasher)
    })
}

/// Create a predicate that checks multiple facts
pub fn multi_fact_predicate<F>(check_fn: F) -> ZeroCopyPredicate
where
    F: Fn(&dyn ZeroCopyFacts) -> bool + 'static,
{
    Rc::new(move |tuple: &dyn ZeroCopyFacts| check_fn(tuple))
}