ring_pair 0.2.1

Tiny fixed-size ring buffer specialized for exactly two elements
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

use core::iter::FusedIterator;

/// Iterator over references to the elements of a ring pair, from oldest to newest.
///
/// Created by calling `.iter()` on a [`RingPair`](crate::RingPair) or
/// [`BoxedRingPair`](crate::BoxedRingPair).
#[derive(Clone)]
pub struct Iter<'a, T> {
    data: [&'a T; 2],
    front: usize,
    back: usize,
}

impl<'a, T> Iter<'a, T> {
    pub(crate) fn new(older: &'a T, newer: &'a T) -> Self {
        Self {
            data: [older, newer],
            front: 0,
            back: 2,
        }
    }
}

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

    fn next(&mut self) -> Option<Self::Item> {
        if self.front < self.back {
            let item = self.data[self.front];
            self.front += 1;
            Some(item)
        } else {
            None
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let len = self.back - self.front;
        (len, Some(len))
    }
}

impl<T> DoubleEndedIterator for Iter<'_, T> {
    fn next_back(&mut self) -> Option<Self::Item> {
        if self.front < self.back {
            self.back -= 1;
            Some(self.data[self.back])
        } else {
            None
        }
    }
}

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

impl<T> FusedIterator for Iter<'_, T> {}