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

use crate::simple_impl::simple_state::KeyProvidingData;

/// Returns matcher for character equal to the one provided as argument.
pub fn char_matcher(c: char) -> impl Fn(&char) -> bool {
    move |k: &char| *k == c
}

/// Returns matcher for character equal to the one provided as argument.
pub fn enumerated_char_matcher(c: char) -> impl Fn(&(usize, char)) -> bool {
    move |k: &(usize, char)| k.1 == c
}

/// Returns matcher for any character not equal to the one provided as argument.
pub fn char_matcher_reversed(c: char) -> impl Fn(&char) -> bool {
    move |k: &char| *k != c
}

/// Unwraps `Result` value without the need of implementing `Debug`. Panics with generic mesage.
/// For tests only.
macro_rules! unwrap_result {
    ($expression:expr) => {
        if let Ok(x) = $expression {
            x
        } else {
            panic!("Result was expected to be Ok(x) but was Err(x)");
        }
    };
}

pub(crate) use unwrap_result;

/// Provides key by repeating specified value for ever.
pub struct SingleValueTestData<T: Copy> {
    value: T,
}

impl <T: Copy> SingleValueTestData<T> {
    pub fn new(value: T) -> Self {
        Self { value }
    }
}

impl <T: Copy> KeyProvidingData<T> for SingleValueTestData<T> {
    fn next_key(&mut self) -> Option<T> {
        Option::Some(self.value)
    }
}

/// Provide key by iterating over a vector of values that implement `Copy` trait.
pub struct CopiedTestData<T> {
    iter: usize,
    values: Vec<T>,
}

impl <T: Copy> CopiedTestData<T> {
    pub fn new(values: Vec<T>) -> Self {
        Self { iter: 0, values }
    }
}

impl <T: Copy> KeyProvidingData<T> for CopiedTestData<T> {
    fn next_key(&mut self) -> Option<T> {
        let ret = self.values.get(self.iter);
        self.iter += 1;
        if let Some(c) = ret {
            return Option::Some(*c)
        }
        Option::None
    }
}

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