fairjax_core 0.1.0

Core package for fairjax
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

use super::PartialMatch;
use crate::{GuardFn, Mapping, MatchedIds, MessageId, Store};

/// Node in mailbox tree
#[derive(Default)]
pub struct Node<const C: usize, P: PartialMatch<C, M> + Default, M> {
    group: P,
    children: Vec<Node<C, P, M>>,
    phantom: std::marker::PhantomData<M>,
}

impl<const C: usize, P: PartialMatch<C, M> + Default, M> Node<C, P, M> {
    pub fn new() -> Self {
        Self {
            group: P::default(),
            children: Vec::new(),
            phantom: std::marker::PhantomData,
        }
    }

    /// Extends mailbox tree with new message
    pub fn ramification(
        &mut self,
        message: &M,
        id: MessageId,
        store: &Store<M>,
        guard_fn: &GuardFn<C, M>,
        mappings: &[Mapping<C>],
    ) -> Option<MatchedIds> {
        if let Some(new_group) = self.group.extend(&message, id) {
            // Run ramification DFS style
            for child in &mut self.children {
                if let Some(result) = child.ramification(message, id, store, guard_fn, &mappings) {
                    return Some(result);
                }
            }

            // Check if match is complete (i.e. not partial)
            if new_group.is_complete() {
                let message_ids: [MessageId; C] = new_group.final_message_ids();

                let messages: [&M; C] = std::array::from_fn(|i| {
                    let id = message_ids[i];
                    &store[&id]
                });

                // Find fairest match that satisfies guard
                for mapping in mappings {
                    if guard_fn(&messages, &mapping) {
                        return Some(MatchedIds::from(message_ids, mapping.clone()));
                    }
                }
            } else {
                // Add child with partial match
                self.children.push(Node {
                    group: new_group,
                    children: Vec::new(),
                    phantom: std::marker::PhantomData,
                });
            }
        }
        None
    }

    /// Remove messages from mailbox tree
    pub fn remove(&mut self, messages: &MatchedIds) {
        self.children
            .retain(|node| node.group.has_common_id(messages));

        for child in &mut self.children {
            child.remove(messages);
        }
    }

    /// Checks if mailbox tree contains no messages
    pub fn is_empty(&self) -> bool {
        self.children.is_empty()
    }
}