compvec/
veclike.rs

1use std::fmt::Display;
2
3/// Defines functionality for an object, which behaves almost like a Vec.
4pub trait VecLike: Sized + From<Vec<Self::Type>> + Clone {
5    type Type: Copy + Default + Display;
6
7    /// Creates a vector like object with capacity.
8    fn with_capacity(c: usize) -> Self;
9
10    /// Creates an empty vector like object.
11    fn new() -> Self {
12        Self::with_capacity(0)
13    }
14
15    /// Returns entry at position i as value.
16    fn get(&self, i: usize) -> Self::Type;
17
18    /// Sets entry at position i with value val.
19    fn set(&mut self, i: usize, val: Self::Type);
20
21    /// Returns the number of stored objects.
22    fn len(&self) -> usize;
23    
24    /// Checks, if the container is empty.
25    fn is_empty(&self) -> bool {
26        self.len() == 0
27    }
28
29    /// Appends an entry.
30    fn push(&mut self, val: Self::Type);
31
32    /// Returns the last entry and deletes it.
33    fn pop(&mut self) -> Option<Self::Type>;
34
35    /// Returns an iterator over all values.
36    fn iterate(&self) -> impl Iterator<Item = Self::Type>;
37
38    /// Moves all elements from another Vec-like structure.
39    fn append(&mut self, other: &mut Self) {
40        for v in other.iterate() {
41            self.push(v);
42        }
43        other.clear();
44    }
45
46    /// Removes all values, but capacity may be unaffected.
47    fn clear(&mut self);
48
49    /// Inserts an element at index.
50    /// This operation may be inefficient, since the vector needs to be restructured.
51    fn insert(&mut self, index: usize, element: Self::Type) {
52        let len_old = self.len();
53        if index > len_old {
54            panic!("insertion index (is {index}) should be <= len (is {len_old})");
55        }
56        if len_old == 1 {
57            if index == 1 {
58                self.push(element);
59            } else {
60                let last = self.get(0);
61                self.push(last);
62                self.set(index, element);
63            }
64        } else {
65            // Copy the last value and append it
66            let last = self.get(len_old - 1);
67            self.push(last);
68            // Store the previous value at index
69            let mut prev = self.get(index);
70            self.set(index, element);
71            // Repeat for all remaining values
72            for i in (index + 1)..self.len() {
73                let tmp = prev;
74                prev = self.get(i);
75                self.set(i, tmp);
76            }
77        }
78    }
79
80    /// Removes an element at index.
81    /// This operation may be inefficient, since the vector needs to be restructured.
82    fn remove(&mut self, index: usize) -> Self::Type {
83        let len = self.len();
84        if index >= len {
85            panic!("removal index (is {index}) should be < len (is {len})");
86        }
87        // Store the deleted value
88        let ret = self.get(index);
89        // Move all values beyond the index
90        for i in index..(len - 1) {
91            let next = self.get(i + 1);
92            self.set(i, next);
93        }
94        // Remove the last one by resizing
95        self.resize(len - 1, Self::Type::default());
96        ret
97    }
98
99    /// Resizes the vector to a given length.
100    fn resize(&mut self, new_len: usize, value: Self::Type);
101    
102    /// Truncates the vector to len.
103    fn truncate(&mut self, len: usize) {
104        if len < self.len() {
105            self.resize(len, Self::Type::default());
106        }
107    }
108    
109    /// Reserves additional space for push values.
110    fn reserve(&mut self, additional: usize);
111}
112
113/// Implement VecLike for Vec in the std-lib.
114impl<T: Copy + Default + Display> VecLike for Vec<T> {
115    type Type = T;
116
117    fn with_capacity(c: usize) -> Self {
118        Vec::<T>::with_capacity(c)
119    }
120
121    fn get(&self, i: usize) -> T {
122        self[i]
123    }
124
125    fn set(&mut self, i: usize, val: T) {
126        self[i] = val;
127    }
128
129    fn len(&self) -> usize {
130        self.len()
131    }
132
133    fn push(&mut self, val: T) {
134        self.push(val);
135    }
136
137    fn pop(&mut self) -> Option<T> {
138        self.pop()
139    }
140
141    fn iterate(&self) -> impl Iterator<Item = T> {
142        self.iter().cloned()
143    }
144
145    // Overwrite implementation of VecLike.
146    fn append(&mut self, other: &mut Self) {
147        self.append(other);
148    }
149
150    fn clear(&mut self) {
151        self.clear();
152    }
153
154    // Overwrite implementation of VecLike.
155    fn insert(&mut self, index: usize, element: Self::Type) {
156        self.insert(index, element);
157    }
158
159    // Overwrite implementation of VecLike.
160    fn remove(&mut self, index: usize) -> Self::Type {
161        self.remove(index)
162    }
163
164    fn resize(&mut self, new_len: usize, value: Self::Type) {
165        self.resize(new_len, value);
166    }
167
168    fn reserve(&mut self, additional: usize) {
169        self.reserve(additional);
170    }
171}
compvec/veclike.rs

compvec/
veclike.rs
