nml2 0.3.1

Convert nmlcc neuro science components into Arbor data formats
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
117
118
119
120
121
122
123

use crate::error::{Error, Result};

#[derive(Debug, Clone)]
struct Action {
    item: String,
    keep: bool,
    wild: bool,
}

#[derive(Debug, Clone)]
pub struct Filter {
    actions: Vec<Action>,
}

impl Filter {
    pub fn discard_all() -> Self {
        Filter {
            actions: vec![Action {
                item: String::new(),
                keep: false,
                wild: true,
            }],
        }
    }

    pub fn retain_all() -> Self {
        Filter {
            actions: vec![Action {
                item: String::new(),
                keep: true,
                wild: true,
            }],
        }
    }

    pub fn new(filter: &str) -> Result<Self> {
        let mut result = Filter {
            actions: Vec::new(),
        };
        for item in filter.split(',') {
            if let Some(it) = item.strip_prefix('+') {
                if let Some(it) = it.strip_suffix('*') {
                    result.retain_prefix(it);
                } else {
                    result.retain(it);
                }
            } else if let Some(it) = item.strip_prefix('-') {
                if let Some(it) = it.strip_suffix('*') {
                    result.discard_prefix(it);
                } else {
                    result.discard(it);
                }
            } else {
                return Err(Error::Parse {
                    what: format!("Couldn't parse filter '{item}' must be [+-][a-zA-Z0-9_]+*?"),
                });
            }
        }
        Ok(result)
    }

    pub fn retain_prefix(&mut self, it: &str) {
        self.actions.push(Action {
            item: it.to_string(),
            keep: true,
            wild: true,
        });
    }

    pub fn retain(&mut self, it: &str) {
        self.actions.push(Action {
            item: it.to_string(),
            keep: true,
            wild: false,
        });
    }

    pub fn discard_prefix(&mut self, it: &str) {
        self.actions.push(Action {
            item: it.to_string(),
            keep: false,
            wild: true,
        });
    }

    pub fn discard(&mut self, it: &str) {
        self.actions.push(Action {
            item: it.to_string(),
            keep: false,
            wild: false,
        });
    }

    pub fn apply(&self, string: &str) -> bool {
        let mut result = true;
        for Action { item, keep, wild } in &self.actions {
            if (*wild && string.starts_with(item)) || string == item {
                result = *keep;
            }
        }
        result
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn filter() {
        let mut filter = Filter::retain_all();
        assert_eq!(filter.apply("abcd"), true);
        filter.discard_prefix("a");
        assert_eq!(filter.apply("abcd"), false);
        filter.retain_prefix("ab");
        assert_eq!(filter.apply("abcd"), true);
        filter.discard_prefix("abc");
        assert_eq!(filter.apply("abcd"), false);
        filter.retain("abcd");
        assert_eq!(filter.apply("abcd"), true);
        assert_eq!(filter.apply("abcq"), false);
    }
}