structex 0.6.0

A structural regular expression 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
62
63
64
65
66
67

use crate::{
    compile::Inst,
    re::{Haystack, RegexEngine},
    se::{Dot, Inner, MatchesInner},
};
use std::sync::Arc;

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Guard {
    pub re: usize,
    pub if_matching: Option<Box<Inst>>,
    pub if_not_matching: Option<Box<Inst>>,
}

impl Guard {
    /// Try to merge this Guard into an existing branch if possible.
    ///
    /// Returns None if merging was successful or Some(self) if not.
    pub(crate) fn try_merge(self, branches: &mut [Inst]) -> Option<Self> {
        for branch in branches.iter_mut() {
            match branch {
                Inst::Guard(g) if self.re == g.re => match (
                    g.if_matching.is_none(),
                    g.if_not_matching.is_none(),
                    self.if_matching.is_none(),
                    self.if_not_matching.is_none(),
                ) {
                    (true, false, false, true) => {
                        g.if_matching = self.if_matching;
                        return None;
                    }
                    (false, true, true, false) => {
                        g.if_not_matching = self.if_not_matching;
                        return None;
                    }
                    _ => (),
                },
                _ => (),
            }
        }

        Some(self)
    }

    pub(super) fn apply<'s, 'h, R, H>(
        &'s self,
        haystack: &'h H,
        dot: Dot,
        inner: Arc<Inner<R>>,
    ) -> Option<MatchesInner<'s, 'h, R, H>>
    where
        R: RegexEngine,
        H: Haystack<R> + ?Sized,
    {
        let (from, to) = dot.loc();
        let is_match = haystack.is_match_between(&inner.re[self.re], from, to);
        match (
            is_match,
            self.if_matching.as_ref(),
            self.if_not_matching.as_ref(),
        ) {
            (true, Some(inst), _) => MatchesInner::new(inst, inner, haystack, dot),
            (false, _, Some(inst)) => MatchesInner::new(inst, inner, haystack, dot),
            _ => None,
        }
    }
}