crabterm 0.1.0

A terminal (UART) server and client
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

pub mod charmap;
pub mod timestamp;

use std::collections::HashMap;

use crate::keybind::config::SettingValue;
pub use charmap::CharmapFilter;
pub use timestamp::TimestampFilter;

/// Trait for filters that transform data
pub trait IoFilter {
    /// Returns whether the filter is currently enabled
    fn enabled(&self) -> bool;

    /// Toggle the filter on/off
    fn toggle(&mut self);

    /// Filter output data (device -> terminal)
    fn filter_out(&mut self, buf: &[u8]) -> Vec<u8> {
        buf.to_vec()
    }

    /// Filter input data (terminal -> device)
    fn filter_in(&mut self, buf: &[u8]) -> Vec<u8> {
        buf.to_vec()
    }
}

/// Manages all available filters
pub struct FilterChain {
    timestamp_filter: TimestampFilter,
    charmap_filter: CharmapFilter,
}

impl FilterChain {
    pub fn new(settings: &HashMap<String, SettingValue>) -> Self {
        let mut timestamp_filter = TimestampFilter::new();
        timestamp_filter.configure(settings);

        let mut charmap_filter = CharmapFilter::new();
        charmap_filter.configure(settings);

        FilterChain {
            timestamp_filter,
            charmap_filter,
        }
    }

    /// Toggle a filter by name. Returns true if the filter exists.
    pub fn toggle(&mut self, name: &str) -> bool {
        match name {
            timestamp::NAME => {
                self.timestamp_filter.toggle();
                true
            }
            charmap::NAME => {
                self.charmap_filter.toggle();
                true
            }
            _ => false,
        }
    }

    /// Apply all active output filters (device -> terminal)
    pub fn filter_out(&mut self, buf: &[u8]) -> Vec<u8> {
        let mut output = buf.to_vec();

        if self.timestamp_filter.enabled() {
            output = self.timestamp_filter.filter_out(&output);
        }

        if self.charmap_filter.enabled() {
            output = self.charmap_filter.filter_out(&output);
        }

        output
    }

    /// Apply all active input filters (terminal -> device)
    pub fn filter_in(&mut self, buf: &[u8]) -> Vec<u8> {
        let mut output = buf.to_vec();

        if self.charmap_filter.enabled() {
            output = self.charmap_filter.filter_in(&output);
        }

        output
    }
}

impl Default for FilterChain {
    fn default() -> Self {
        Self::new(&HashMap::new())
    }
}