mainframe 1.0.1

A lightweight TUI system monitor
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

/// Module `ringbuffer.rs` implements a `RingBuffer` object for managing
/// wrapping fixed-size buffers.
use std::cmp::min;

/// RingBuffer is a wrapper around std::Vec, which holds a predefined amount
/// of items, and for which inserts on a full buffer will push items off the
/// end of the list.
pub struct RingBuffer<T>
where
    T: Clone + Default,
{
    size: usize,
    count: usize,
    head: usize,
    data: Vec<T>,
}

impl<T> RingBuffer<T>
where
    T: Clone + Default,
{
    /// Creates a new [`RingBuffer`] object of size `size`.
    pub fn new(size: usize) -> Self {
        let mut data = Vec::<T>::new();
        data.reserve(size);

        RingBuffer {
            head: 0,
            count: 0,
            size,
            data,
        }
    }

    /// Add the new given item `x` to the front of the ring buffer.
    pub fn add(&mut self, x: T) {
        if self.data.len() < self.size {
            self.data.push(x);
        } else {
            self.data[self.head] = x;
        }

        self.head = (self.head + 1) % self.size;
        self.count = min(self.count + 1, self.size);
    }

    pub fn last(&self) -> Option<&T> {
        match self.count {
            0 => None,
            _ => Some(self.peek(self.head)),
        }
    }

    /// Return ring buffer item at position `idx`.
    ///
    /// Indeces greater than the size of the ring buffer will simply wrap around.
    pub fn peek(&self, idx: usize) -> &T {
        &self.data[idx % self.size]
    }

    /// Get the length of the ring buffer
    pub fn size(&self) -> usize {
        self.size
    }

    /// Get the count of current items in the ring buffer.
    ///
    /// Note that this will never be less than 0, nor more than the size of
    /// the buffer.
    pub fn count(&self) -> usize {
        self.count
    }
}

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

    #[test]
    fn test_create() {
        let rb = RingBuffer::<f32>::new(10);

        assert!(rb.size() == 10);
        assert!(rb.count() == 0);
    }

    #[test]
    fn test_add() {
        let mut rb = RingBuffer::<f32>::new(5);
        rb.add(1.0);
        rb.add(2.0);
        rb.add(3.0);

        assert!(rb.count() == 3);
        assert!(rb.size() == 5);

        rb.add(0.0);
        rb.add(0.0);
        rb.add(0.0);
        rb.add(0.0);

        assert!(rb.count() == 5);
        assert!(rb.size() == 5);
        assert!(rb.data.len() == 5);
    }

    #[test]
    fn test_peek() {
        let mut rb = RingBuffer::<f32>::new(3);
        rb.add(1_f32);
        rb.add(2_f32);
        rb.add(3_f32);

        assert!(rb.peek(0) == &1f32);
        assert!(rb.peek(1) == &2f32);
        assert!(rb.peek(2) == &3f32);
    }

    #[test]
    fn test_use() {
        let mut rb = RingBuffer::<f32>::new(3);

        rb.add(1_f32);
        rb.add(2_f32);
        rb.add(3_f32);

        assert!(rb.peek(0) == &1f32);
        assert!(rb.peek(1) == &2f32);
        assert!(rb.peek(2) == &3f32);

        rb.add(4_f32);
        rb.add(5_f32);
        rb.add(6_f32);

        assert!(rb.peek(0) == &4f32);
        assert!(rb.peek(1) == &5f32);
        assert!(rb.peek(2) == &6f32);
    }
}