Implement DoubleEndedIterator for HistoryBuffer::oldest_ordered

[Eugeny]

Would be very useful and seems relatively straightforward to implement ✌️

[Eugeny]

Here's a "dumb" outside-the-crate implementation:

pub struct HistoryBufferDoubleEndedIterator<'a, T, const N: usize> {
    buf: &'a HistoryBuffer<T, N>,
    cur: usize,
    cur_back: usize,
}

impl<'a, T, const N: usize> HistoryBufferDoubleEndedIterator<'a, T, N> {
    pub fn new(buf: &'a HistoryBuffer<T, N>) -> Self {
        Self {
            buf,
            cur: 0,
            cur_back: buf.len(),
        }
    }
}

impl<'a, T, const N: usize> ExactSizeIterator for HistoryBufferDoubleEndedIterator<'a, T, N> {}

impl<'a, T, const N: usize> Iterator for HistoryBufferDoubleEndedIterator<'a, T, N> {
    type Item = &'a T;

    fn next(&mut self) -> Option<&'a T> {
        let (a, b) = self.buf.as_slices();
        self.cur += 1;
        if self.cur < a.len() {
            Some(&a[self.cur])
        } else if self.cur < a.len() + b.len() {
            Some(&b[self.cur - a.len()])
        } else {
            None
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        (self.buf.len(), Some(self.buf.len()))
    }
}

impl<'a, T, const N: usize> DoubleEndedIterator for HistoryBufferDoubleEndedIterator<'_, T, N> {
    fn next_back(&mut self) -> Option<Self::Item> {
        let (a, b) = self.buf.as_slices();
        if self.cur_back == 0 {
            return None;
        }
        self.cur_back -= 1;
        if self.cur_back < a.len() {
            Some(&a[self.cur_back])
        } else if self.cur_back < a.len() + b.len() {
            Some(&b[self.cur_back - a.len()])
        } else {
            None
        }
    }
}

[witek103]

you can look at #449