regexml 0.2.2

XPath compatible regex 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
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

use crate::{
    operation::{Operation, OperationControl, RepeatOperation, MATCHES_ZLS_ANYWHERE},
    re_flags::ReFlags,
    re_matcher::ReMatcher,
};

// Handle a repetition where there is no ambiguity; if the repeated
// term is matched in the string, then it cannot match anything other than
// the repeated term. It is also used when the number of occurrences is
// fixed. In this situation there will never be any need for
// backtracking, so there is no need to keep any information to support
// backtracking, and in addition, there is no distinction between greedy
// and reluctant matching. This operation is used only for a repeated
// atom or CharClass, which also means that if the repeated term matches
// then it can only match in one way; a typical example is the term "A*"
// in the regex "A*B".
#[derive(Debug, Clone)]
pub(crate) struct UnambiguousRepeat {
    operation: Box<Operation>,
    pub(crate) min: usize,
    max: usize,
}

impl UnambiguousRepeat {
    pub(crate) fn new(operation: Operation, min: usize, max: usize) -> Self {
        Self {
            operation: operation.into(),
            min,
            max,
        }
    }
}

impl OperationControl for UnambiguousRepeat {
    fn get_match_length(&self) -> Option<usize> {
        self.operation.get_match_length().and_then(|match_length| {
            if self.min == self.max {
                Some(self.min * match_length)
            } else {
                None
            }
        })
    }

    fn get_minimum_match_length(&self) -> usize {
        self.min * self.operation.get_minimum_match_length()
    }

    fn matches_empty_string(&self) -> u32 {
        if self.min == 0 {
            MATCHES_ZLS_ANYWHERE
        } else {
            self.operation.matches_empty_string()
        }
    }

    fn optimize(self, flags: &ReFlags) -> Operation {
        Operation::from(UnambiguousRepeat {
            operation: self.operation.optimize(flags).into(),
            min: self.min,
            max: self.max,
        })
    }

    fn contains_capturing_expressions(&self) -> bool {
        matches!(self.operation.as_ref(), Operation::Capture(_))
            || self.operation.contains_capturing_expressions()
    }

    fn matches_iter<'a>(
        &self,
        matcher: &'a ReMatcher,
        position: usize,
    ) -> Box<dyn Iterator<Item = usize> + 'a> {
        let guard = matcher.search.len();

        let mut p = position;
        let mut matches = 0;
        while matches < self.max && p <= guard {
            let mut iter = self.operation.matches_iter(matcher, p);
            if let Some(n) = iter.next() {
                p = n;
                matches += 1;
            } else {
                break;
            }
        }
        if matches < self.min {
            Box::new(std::iter::empty())
        } else {
            Box::new(std::iter::once(p))
        }
    }

    fn children(&self) -> Vec<Operation> {
        vec![self.operation.as_ref().clone()]
    }
}

impl RepeatOperation for UnambiguousRepeat {
    fn child(&self) -> Operation {
        self.operation.as_ref().clone()
    }

    fn min(&self) -> usize {
        self.min
    }

    fn max(&self) -> usize {
        self.max
    }

    fn greedy(&self) -> bool {
        true
    }
}