downsample 0.0.6

keep downsampled history of data over long period of time
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

use crate::fixed_frequency::storage::LevelMetadata;

pub struct LevelView<'a, T> {
    data:  &'a [T],
    level: &'a LevelMetadata,
}

impl<'a, T> LevelView<'a, T> {
    pub(crate) fn new(data: &'a [T], level: &'a LevelMetadata) -> Self { Self { data, level } }

    pub fn len(&self) -> usize { self.level.sample_capacity() }

    pub fn is_empty(&self) -> bool { self.len() == 0 }

    pub fn get(&self, index: usize) -> Option<&'a T> {
        if index >= self.len() {
            return None;
        }

        Some(&self.data[self.level.readable_position(index)])
    }

    pub fn iter_oldest_first(&self) -> LevelIter<'a, T> {
        LevelIter {
            data:  self.data,
            level: self.level,
            index: 0,
        }
    }
}

pub struct LevelIter<'a, T> {
    data:  &'a [T],
    level: &'a LevelMetadata,
    index: usize,
}

impl<'a, T> Iterator for LevelIter<'a, T> {
    type Item = &'a T;

    fn next(&mut self) -> Option<Self::Item> {
        if self.index >= self.level.sample_capacity() {
            return None;
        }

        let pos = self.level.readable_position(self.index);
        self.index += 1;
        Some(&self.data[pos])
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let remaining = self.level.sample_capacity() - self.index;
        (remaining, Some(remaining))
    }
}

impl<T> ExactSizeIterator for LevelIter<'_, T> {}

#[cfg(all(test, feature = "reducers"))]
mod tests {
    use crate::{FixedFrequencyBuilder, FixedWriter, reducers};
    use alloc::vec::Vec;
    use core::num::NonZeroUsize;

    const fn nz(value: usize) -> NonZeroUsize { NonZeroUsize::new(value).expect("expected non-zero value") }

    fn storage() -> FixedWriter<f32> {
        FixedFrequencyBuilder::new(nz(3))
            .level(nz(2), nz(2), reducers::average_f32())
            .build()
    }

    #[test]
    fn view_get_skips_aggregation_window() {
        let mut s = storage();
        for value in 1..=9 {
            s.push(value as f32);
        }

        let view = s.storage().level(0).unwrap();
        assert_eq!(view.len(), 3);
        assert!(!view.is_empty());
        assert_eq!(view.get(0), Some(&7.0));
        assert_eq!(view.get(1), Some(&8.0));
        assert_eq!(view.get(2), Some(&9.0));
        assert_eq!(view.get(3), None);
    }

    #[test]
    fn iter_yields_oldest_first_after_wraparound() {
        let mut s = storage();
        for value in 1..=9 {
            s.push(value as f32);
        }

        let values: Vec<_> = s.storage().level(0).unwrap().iter_oldest_first().copied().collect();
        assert_eq!(values, [7.0, 8.0, 9.0]);
    }

    #[test]
    fn final_level_view_reads_all_slots() {
        let mut s = storage();
        for value in 1..=9 {
            s.push(value as f32);
        }

        let values: Vec<_> = s.storage().level(1).unwrap().iter_oldest_first().copied().collect();
        assert_eq!(values, [3.5, 5.5]);
    }

    #[test]
    fn iter_size_hint_tracks_remaining_items() {
        let mut s = storage();
        for value in 1..=9 {
            s.push(value as f32);
        }

        let view = s.storage().level(0).unwrap();
        let mut iter = view.iter_oldest_first();
        assert_eq!(iter.size_hint(), (3, Some(3)));
        assert_eq!(iter.next(), Some(&7.0));
        assert_eq!(iter.size_hint(), (2, Some(2)));
        assert_eq!(iter.next(), Some(&8.0));
        assert_eq!(iter.next(), Some(&9.0));
        assert_eq!(iter.size_hint(), (0, Some(0)));
        assert_eq!(iter.next(), None);
    }
}