1 use fst::Automaton;
2 
3 use crate::{StateID, DFA};
4 
5 macro_rules! imp {
6     ($ty:ty, $id:ty) => {
7         impl<T: AsRef<[$id]>, S: StateID> Automaton for $ty {
8             type State = S;
9 
10             #[inline]
11             fn start(&self) -> S {
12                 self.start_state()
13             }
14 
15             #[inline]
16             fn is_match(&self, state: &S) -> bool {
17                 self.is_match_state(*state)
18             }
19 
20             #[inline]
21             fn accept(&self, state: &S, byte: u8) -> S {
22                 self.next_state(*state, byte)
23             }
24 
25             #[inline]
26             fn can_match(&self, state: &S) -> bool {
27                 !self.is_dead_state(*state)
28             }
29         }
30     };
31 }
32 
33 imp!(crate::dense::DenseDFA<T, S>, S);
34 imp!(crate::dense::Standard<T, S>, S);
35 imp!(crate::dense::ByteClass<T, S>, S);
36 imp!(crate::dense::Premultiplied<T, S>, S);
37 imp!(crate::dense::PremultipliedByteClass<T, S>, S);
38 imp!(crate::sparse::SparseDFA<T, S>, u8);
39 imp!(crate::sparse::Standard<T, S>, u8);
40 imp!(crate::sparse::ByteClass<T, S>, u8);
41 
42 #[cfg(test)]
43 mod tests {
44     use bstr::BString;
45     use fst::{Automaton, IntoStreamer, Set, Streamer};
46 
47     use crate::dense::{self, DenseDFA};
48     use crate::sparse::SparseDFA;
49 
search<A: Automaton, D: AsRef<[u8]>>( set: &Set<D>, aut: A, ) -> Vec<BString>50     fn search<A: Automaton, D: AsRef<[u8]>>(
51         set: &Set<D>,
52         aut: A,
53     ) -> Vec<BString> {
54         let mut stream = set.search(aut).into_stream();
55 
56         let mut results = vec![];
57         while let Some(key) = stream.next() {
58             results.push(BString::from(key));
59         }
60         results
61     }
62 
63     #[test]
dense_anywhere()64     fn dense_anywhere() {
65         let set =
66             Set::from_iter(&["a", "bar", "baz", "wat", "xba", "xbax", "z"])
67                 .unwrap();
68         let dfa = DenseDFA::new("ba.*").unwrap();
69         let got = search(&set, &dfa);
70         assert_eq!(got, vec!["bar", "baz", "xba", "xbax"]);
71     }
72 
73     #[test]
dense_anchored()74     fn dense_anchored() {
75         let set =
76             Set::from_iter(&["a", "bar", "baz", "wat", "xba", "xbax", "z"])
77                 .unwrap();
78         let dfa = dense::Builder::new().anchored(true).build("ba.*").unwrap();
79         let got = search(&set, &dfa);
80         assert_eq!(got, vec!["bar", "baz"]);
81     }
82 
83     #[test]
sparse_anywhere()84     fn sparse_anywhere() {
85         let set =
86             Set::from_iter(&["a", "bar", "baz", "wat", "xba", "xbax", "z"])
87                 .unwrap();
88         let dfa = SparseDFA::new("ba.*").unwrap();
89         let got = search(&set, &dfa);
90         assert_eq!(got, vec!["bar", "baz", "xba", "xbax"]);
91     }
92 
93     #[test]
sparse_anchored()94     fn sparse_anchored() {
95         let set =
96             Set::from_iter(&["a", "bar", "baz", "wat", "xba", "xbax", "z"])
97                 .unwrap();
98         let dfa = dense::Builder::new()
99             .anchored(true)
100             .build("ba.*")
101             .unwrap()
102             .to_sparse()
103             .unwrap();
104         let got = search(&set, &dfa);
105         assert_eq!(got, vec!["bar", "baz"]);
106     }
107 }
108