generational_cache/vector/
mod.rs

1//! Module providing abstractions for reperesenting vectors.
2
3use core::ops::DerefMut;
4
5/// Represents an abstract vector over a type accessible as mutable slice.
6pub trait Vector<T>: DerefMut<Target = [T]> {
7    type Error: core::fmt::Debug;
8
9    /// Reserves memory for the given number of additional items in this vector.
10    fn reserve(&mut self, additional: usize) -> Result<(), Self::Error>;
11
12    /// Returns the number of items this vector is capable of storing.
13    fn capacity(&self) -> usize;
14
15    /// Pushes a new element to the end of this vector.
16    fn push(&mut self, item: T) -> Result<(), Self::Error>;
17
18    /// Removes all elements from this vector.
19    fn clear(&mut self);
20}
21
22pub mod impls;
23
24#[doc(hidden)]
25pub mod tests {
26    use super::Vector;
27
28    pub fn _test_vector_consistency<V: Vector<usize>>(mut vector: V) {
29        vector.clear();
30
31        let cap_0 = vector.capacity();
32
33        vector.reserve(vector.capacity()).unwrap();
34
35        let cap_1 = vector.capacity();
36
37        assert_eq!(cap_0, cap_1);
38
39        assert!(vector.is_empty());
40
41        for i in 0..vector.capacity() {
42            vector.push(i).unwrap();
43        }
44
45        assert_eq!(vector.len(), vector.capacity());
46
47        for (j, i) in vector.iter().enumerate() {
48            assert_eq!(i, &j);
49        }
50
51        let cap_0 = vector.capacity();
52
53        let res = vector.push(42);
54
55        let cap_1 = vector.capacity();
56
57        if cap_0 == cap_1 {
58            assert!(res.is_err());
59        } else {
60            assert!(cap_1 > cap_0, "Capacity decreased on push().");
61            assert!(res.is_ok());
62        }
63
64        let cap_0 = vector.capacity();
65
66        vector.clear();
67
68        let cap_1 = vector.capacity();
69
70        assert!(cap_0 == cap_1, "Capacity changed on clear().");
71
72        assert!(vector.is_empty());
73
74        const ADDITIONAL: usize = 5;
75
76        let result = vector.reserve(ADDITIONAL);
77
78        if result.is_err() {
79            return;
80        }
81
82        for i in 0..ADDITIONAL {
83            vector.push(i).unwrap();
84        }
85    }
86}