automata-like-programming 0.2.0

Library that provides mechanisms for controlling the flow of execution in imitation of an automaton.
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

/// Builder like implementation for creating linked sequences of states. Modifies passed
/// instances on the fly.
pub mod definer;
pub mod builder;

/// Simplifies creation of series by creating states based on provided iterator and connects them coninously starting from root.
/// Returns all states created in the process. Function can be passed to be executed at any default state switch (when no states
/// from series can be matched). Function to be executed while switching states can also be provided. Most useful for long patterns.
/// !!! WARNING Won't create returning connections for matched starting patterns (starting elements existing in further parts of
/// matched pattern meanining that new match could be possible while current match is still being processed).
/// # Examples
/// ```
/// use std::{cell::RefCell, rc::Rc};
/// use automata_like_programming::{
///     series,
///     automaton::Automaton,
///     automaton_state::new_shared_concrete_state,
///     simple_impl::simple_state::{
///         KeyProvidingData,
///         SimpleInterStateConnection,
///         SimpleStateImplementation,
///     }
/// };
/// # pub fn enumerated_char_matcher(c: char) -> impl Fn(&(usize, char)) -> bool {
/// #     move |k: &(usize, char)| k.1 == c
/// # }
/// # pub struct MatchListCopiedTestData<T> {
/// #     iter: usize,
/// #     values: Vec<T>,
/// #     matches: Vec<usize>,
/// # }
/// # 
/// # impl <T: Copy> MatchListCopiedTestData<T> {
/// #     pub fn new(values: Vec<T>) -> Self {
/// #         Self { iter: 0, values, matches: Vec::new() }
/// #     }
/// # 
/// #     pub fn set_match(&mut self, match_end: usize) -> () {
/// #         self.matches.push(match_end);
/// #     }
/// # 
/// #     pub fn matches(&self) -> &Vec<usize> {
/// #         &self.matches
/// #     }
/// # }
/// # 
/// # impl <T: Copy> KeyProvidingData<(usize, T)> for MatchListCopiedTestData<T> {
/// #     fn next_key(&mut self) -> Option<(usize,T)> {
/// #         let current_iter = self.iter;
/// #         let ret = self.values.get(self.iter);
/// #         self.iter += 1;
/// #         if let Some(c) = ret {
/// #             return Option::Some((current_iter,*c))
/// #         }
/// #         Option::None
/// #     }
/// # }
/// 
/// let mut automaton = Automaton::new({
/// let root: Rc<RefCell<SimpleStateImplementation<'_, (usize, char), u8, MatchListCopiedTestData<char>, String>>> = new_shared_concrete_state(SimpleStateImplementation::new(0));
/// let a2: Rc<RefCell<SimpleStateImplementation<'_, (usize, char), u8, MatchListCopiedTestData<char>, String>>> = new_shared_concrete_state(SimpleStateImplementation::new(4));
/// 
/// let defined_states = series!(
///                         // Iterator for generating states
///                         "abb".chars(),
///                         // Root node which will be the start of the series
///                         root,
///                         // Generator for matchers - creates matchers for enumerated elements from iterator
///                         enumerated_char_matcher,
///                         // Id generator - creates id values to be assigned to states
///                         |i, _| i as u8
///                      );
/// assert_eq!(defined_states.len(), 3);
/// defined_states.get(2).unwrap().borrow_mut().register_connection(
///     SimpleInterStateConnection::new(enumerated_char_matcher('a'),
///     |data, k| {
///         data.set_match(k.0);
///         Result::Ok(())
///     },
///     &a2));
/// defined_states.get(2).unwrap().borrow_mut().register_connection(
///     SimpleInterStateConnection::new_no_action(enumerated_char_matcher('a'), defined_states.get(0).unwrap())
/// );
/// a2.borrow_mut().register_connection(SimpleInterStateConnection::new_no_action_always_matched(&root));
/// root.borrow_mut().register_connection(SimpleInterStateConnection::new_no_action_always_matched(&root));
/// root
/// });
/// // Searched pattern starts at index 2 and ends on index 5 (abba).
/// let mut data = MatchListCopiedTestData::new("aaabbaba".chars().collect());
/// let automaton_result = automaton.run(&mut data);
/// assert!(automaton_result.is_empty_iter());
/// // Found one match.
/// assert_eq!(data.matches().len(), 1);
/// // Found match ending on 5th character.
/// assert_eq!(*data.matches().get(0).unwrap(), 5);
/// ```
#[macro_export]
macro_rules! series {
    ($iter:expr, $root:ident, $matcher_gen:ident, $id_gen:expr) => {
        $crate::series!($iter, $root, $matcher_gen, $id_gen, |_,_| {Result::Ok(())})
    };
    ($iter:expr, $root:ident, $matcher_gen:ident, $id_gen:expr, $default_exec:expr) => {
        $crate::series!($iter, $root, $matcher_gen, $id_gen, |_,_| {Result::Ok(())}, |_,_| {Result::Ok(())})
    };
    ($iter:expr, $root:ident, $matcher_gen:ident, $id_gen:expr, $default_exec:expr, $inter_state_exec:expr) => {
        {
            let mut defined_states = Vec::new();
            let mut definer = $crate::simple_impl::series::definer::SeriesDefiner::new(&$root, $default_exec);
            for x in $iter.enumerate() {
                let state = $crate::automaton_state::new_shared_concrete_state(SimpleStateImplementation::new(($id_gen)(x.0, x.1)));
                definer = definer.next_state_exec(($matcher_gen)(x.1), &state, $inter_state_exec);
                defined_states.push(state);
            }
            defined_states
        }
    };
}

#[cfg(test)]
mod tests {
    use std::{cell::RefCell, rc::Rc};

    use crate::{automaton::Automaton, automaton_state::new_shared_concrete_state, simple_impl::simple_state::{SimpleInterStateConnection, SimpleStateImplementation}, test_commons::{enumerated_char_matcher, MatchListCopiedTestData}};

    #[test]
    fn series_from_string() -> () {
        let mut automaton = Automaton::new({
            let root: Rc<RefCell<SimpleStateImplementation<'_, (usize, char), u8, MatchListCopiedTestData<char>, String>>> = new_shared_concrete_state(SimpleStateImplementation::new(0));
            let a2: Rc<RefCell<SimpleStateImplementation<'_, (usize, char), u8, MatchListCopiedTestData<char>, String>>> = new_shared_concrete_state(SimpleStateImplementation::new(4));

            let defined_states = series!(
                                                                                // Iterator for generating states
                                                                                "abb".chars(),
                                                                                // Root node which will be the start of the series
                                                                                root,
                                                                                // Generator for matchers - creates matchers for enumerated elements from iterator
                                                                                enumerated_char_matcher,
                                                                                // Id generator - creates id values to be placed in states
                                                                                |i, _| i as u8);
            assert_eq!(defined_states.len(), 3);
            defined_states.get(2).unwrap().borrow_mut().register_connection(SimpleInterStateConnection::new(enumerated_char_matcher('a'), |data, k| {
                data.set_match(k.0);
                Result::Ok(())
            }, &a2));
            defined_states.get(2).unwrap().borrow_mut().register_connection(SimpleInterStateConnection::new_no_action(enumerated_char_matcher('a'), defined_states.get(0).unwrap()));
            a2.borrow_mut().register_connection(SimpleInterStateConnection::new_no_action_always_matched(&root));
            root.borrow_mut().register_connection(SimpleInterStateConnection::new_no_action_always_matched(&root));
            root
        });
        let mut data = MatchListCopiedTestData::new("aaabbaba".chars().collect());
        let automaton_result = automaton.run(&mut data);
        assert!(automaton_result.is_empty_iter());
        assert_eq!(data.matches().len(), 1);
        assert_eq!(*data.matches().get(0).unwrap(), 5);
    }
}