redirectionio 3.1.0

Redirection IO Library to handle matching rule, redirect and filtering headers and body.
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

use super::{item::Item, leaf::Leaf, node::Node};

#[derive(Debug, Clone)]
pub struct Trace<'a, V> {
    pub(crate) regex: String,
    pub(crate) count: u64,
    pub(crate) matched: bool,
    pub(crate) children: Vec<Trace<'a, V>>,
    pub(crate) values: Vec<&'a V>,
}

impl<V> Leaf<V> {
    pub fn trace(&self, haystack: &str) -> Trace<'_, V> {
        let matched = self.regex.is_match(haystack);

        Trace {
            regex: self.regex.original.clone(),
            matched,
            count: self.values.len() as u64,
            children: Vec::new(),
            values: self.values.values().collect(),
        }
    }
}
impl<V> Node<V> {
    pub fn trace(&self, haystack: &str) -> Trace<'_, V> {
        let mut children = Vec::new();
        let matched = self.regex.is_match(haystack);

        if matched {
            for child in &self.children {
                children.push(child.trace(haystack));
            }
        }

        Trace {
            regex: self.regex.original.clone(),
            matched,
            count: self.len() as u64,
            children,
            values: Vec::new(),
        }
    }
}

impl<V> Item<V> {
    pub fn trace(&self, haystack: &str) -> Trace<'_, V> {
        match self {
            Item::Empty(_) => Trace {
                regex: "".to_string(),
                matched: true,
                count: 0,
                children: Vec::new(),
                values: Vec::new(),
            },
            Item::Node(node) => node.trace(haystack),
            Item::Leaf(leaf) => leaf.trace(haystack),
        }
    }
}