actiondb 0.3.0

A safe and efficient unstructured text (log) parsing library.
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

use std::collections::BTreeMap;

use parsers::ParseResult;
use matcher::Pattern;

#[derive(Debug)]
pub struct MatchResult<'a, 'b> {
    pattern: &'a Pattern,
    values: BTreeMap<&'a str, &'b str>
}

impl <'a, 'b> MatchResult<'a, 'b> {
    pub fn new(pattern: &'a Pattern) -> MatchResult<'a, 'b> {
        MatchResult{
            pattern: pattern,
            values: BTreeMap::new()
        }
    }

    pub fn insert(&mut self, result: ParseResult<'a, 'b>) {
        if let Some(name) = result.parser().name() {
            self.values.insert(name, result.value());
        }
    }

    pub fn pattern(&self) -> &Pattern {
        self.pattern
    }

    pub fn values(&self) -> &BTreeMap<&'a str, &'b str> {
        &self.values
    }
}

#[cfg(test)]
mod test {
    use parsers::{IntParser, ParseResult};
    use super::MatchResult;
    use matcher::Pattern;

    #[test]
    fn test_given_match_result_when_a_parse_result_is_inserted_then_we_use_only_the_ones_where_the_parser_has_a_name() {
        let parser_wo_name = IntParser::new();
        let parser_with_name = IntParser::with_name("name".to_string());
        let expected_values = btreemap!{"name" => "c"};
        let pattern = Pattern::with_random_uuid();
        let mut match_result = MatchResult::new(&pattern);
        match_result.insert(ParseResult::new(&parser_wo_name, "a"));
        match_result.insert(ParseResult::new(&parser_wo_name, "b"));
        match_result.insert(ParseResult::new(&parser_with_name, "c"));
        assert_eq!(match_result.values(), &expected_values);
    }
}