ladata 0.0.29

A simple & modular data model.
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

// ladata::list::queue
//
//! Queues are linear lists for which addittions are made at one end,
//! and removals are made at the opposite end.
//

use crate::{list::Array, mem::Storage};

#[cfg(feature = "alloc")]
use crate::mem::Boxed;

mod data;
mod impls;
mod methods;

pub use data::DataQueue;

/// A queue, backed by an [`Array`].
pub struct Queue<T, S: Storage, const CAP: usize> {
    pub(crate) array: Array<T, S, CAP>,
    pub(crate) len: usize,
    pub(crate) front: usize,
    pub(crate) back: usize,
}

// /// A queue, backed by a [`Vec`].
// pub struct Queue<T> {
//     vec: Vec<T>,
//     front: usize,
//     back: usize,
// }

/// A [`Queue`] stored in the stack.
pub type DirectQueue<T, const CAP: usize> = Queue<T, (), CAP>;

/// A [`Queue`] stored in the heap.
#[cfg(feature = "alloc")]
#[cfg_attr(feature = "nightly", doc(cfg(feature = "alloc")))]
pub type BoxedQueue<T, const CAP: usize> = Queue<T, Boxed, CAP>;

/* iterators */

/// A queue iterator.
pub struct QueueIter<'s, T, S: Storage, const CAP: usize> {
    queue: &'s Queue<T, S, CAP>,
    idx: usize,
}

impl<'s, T, S: Storage, const CAP: usize> Iterator for QueueIter<'s, T, S, CAP> {
    type Item = &'s T;
    /// Iterates over shared references.
    ///
    /// # Example
    /// ```
    /// use ladata::all::DirectQueue;
    ///
    /// let mut q = DirectQueue::<i32, 4>::from([1, 2]);
    /// q.pop();
    /// q.push(3);
    /// q.pop();
    /// q.push(4);
    ///
    /// let mut qi = q.iter();
    /// assert_eq![Some(&3), qi.next()];
    /// assert_eq![Some(&4), qi.next()];
    /// assert_eq![None, qi.next()];
    ///
    /// ```
    fn next(&mut self) -> Option<Self::Item> {
        let item = if self.idx == self.queue.len() {
            None
        } else {
            Some(&self.queue.array[self.queue.idx_front(self.idx)])
        };
        self.idx += 1;
        item
    }

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

impl<'s, T, S: Storage, const CAP: usize> ExactSizeIterator for QueueIter<'s, T, S, CAP> {}