sid_vec/
id_vector.rs

1use super::{ Identifier, FromIndex, ToIndex, IdRange, IntegerHandle };
2use std::default::Default;
3use std::slice;
4use std::marker::PhantomData;
5use std::ops;
6use std::iter::IntoIterator;
7
8/// Similar to Vec except that it is indexed using an Id rather than an usize index.
9/// if the stored type implements Default, IdVec can also use the set(...) method which can
10/// grow the vector to accomodate for the requested id.
11pub struct IdVec<ID:Identifier, Data> {
12    data: Vec<Data>,
13    _idtype: PhantomData<ID>
14}
15
16impl<ID:Identifier, Data> IdVec<ID, Data> {
17
18    /// Create an empty IdVec
19    pub fn new() -> IdVec<ID, Data> {
20        IdVec {
21            data: Vec::new(),
22            _idtype: PhantomData
23        }
24    }
25
26    /// Create an IdVec with preallocated storage
27    pub fn with_capacity(size: ID::Handle) -> IdVec<ID, Data> {
28        IdVec {
29            data: Vec::with_capacity(size.to_index()),
30            _idtype: PhantomData
31        }
32    }
33
34    /// Create an IdVec by recycling a Vec and its content.
35    pub fn from_vec(vec: Vec<Data>) -> IdVec<ID, Data> {
36        IdVec {
37            data: vec,
38            _idtype: PhantomData
39        }
40    }
41
42    /// Consume the IdVec and create a Vec.
43    pub fn into_vec(self) -> Vec<Data> { self.data }
44
45    /// Number of elements in the IdVec
46    pub fn len(&self) -> usize { self.data.len() }
47
48    /// Return the nth element of the IdVec using an usize index rather than an Id (à la Vec).
49    pub fn nth(&self, idx: usize) -> &Data { &self.data[idx] }
50
51    /// Return the nth element of the IdVec using an usize index rather than an Id (à la Vec).
52    pub fn nth_mut(&mut self, idx: usize) -> &mut Data { &mut self.data[idx] }
53
54    /// Iterate over the elements of the IdVec
55    pub fn iter<'l>(&'l self) -> slice::Iter<'l, Data> { self.data.iter() }
56
57    /// Iterate over the elements of the IdVec
58    pub fn iter_mut<'l>(&'l mut self) -> slice::IterMut<'l, Data> { self.data.iter_mut() }
59
60    /// Add an element to the IdVec and return its Id.
61    /// This method can cause the storage to be reallocated.
62    pub fn push(&mut self, elt: Data) -> ID {
63        let index = self.data.len();
64        self.data.push(elt);
65        return FromIndex::from_index(index);
66    }
67
68    /// Drop all of the contained elements and clear the IdVec's storage.
69    pub fn clear(&mut self) {
70        self.data.clear();
71    }
72}
73
74impl<ID:Identifier, Data: Default> IdVec<ID, Data> {
75    /// Set the value for a certain Id, possibly adding default values if the Id's index is Greater
76    /// than the size of the underlying vector.
77    pub fn set(&mut self, id: ID, val: Data) {
78        while self.len() < id.to_index() {
79            self.push(Data::default());
80        }
81        if self.len() == id.to_index() {
82            self.push(val);
83        } else {
84            self[id] = val;
85        }
86    }
87}
88
89impl<Data:Default, ID:Identifier> IdVec<ID, Data> {
90    pub fn resize(&mut self, size: ID::Handle) {
91        if size.to_index() > self.data.len() {
92            let d = size.to_index() - self.data.len();
93            self.data.reserve(d as usize);
94            for _ in 0 .. d {
95                self.data.push(Default::default());
96            }
97        } else {
98            let d = self.data.len() - size.to_index();
99            for _ in 0 .. d {
100                self.data.pop();
101            }
102        }
103    }
104
105    /// Creates an IdVec with an n elements initialized to `Default::default`.
106    pub fn with_len(n: ID::Handle) -> Self {
107        let mut result: IdVec<ID, Data> = IdVec::with_capacity(n);
108        result.resize(n);
109        return result;
110    }
111}
112
113impl<ID:Identifier, Data> ops::Index<ID> for IdVec<ID, Data> {
114    type Output = Data;
115    fn index<'l>(&'l self, id: ID) -> &'l Data { &self.data[id.to_index()] }
116}
117
118impl<ID:Identifier, Data> ops::IndexMut<ID> for IdVec<ID, Data> {
119    fn index_mut<'l>(&'l mut self, id: ID) -> &'l mut Data { &mut self.data[id.to_index()] }
120}
121
122
123pub struct IdSlice<'l, ID:Identifier, Data> where Data:'l {
124    slice: &'l[Data],
125    _idtype: PhantomData<ID>
126}
127
128impl<'l, Data, ID:Identifier> Copy for IdSlice<'l, ID, Data> where Data:'l {}
129impl<'l, Data, ID:Identifier> Clone for IdSlice<'l, ID, Data> where Data:'l {
130    fn clone(&self) -> IdSlice<'l, ID, Data> {
131        IdSlice {
132            slice: self.slice,
133            _idtype: PhantomData,
134        }
135    }
136}
137
138impl<'l, Data, ID:Identifier> IdSlice<'l, ID, Data> where Data:'l {
139    pub fn new(slice: &'l[Data]) -> IdSlice<'l, ID, Data> {
140        IdSlice {
141            slice: slice,
142            _idtype: PhantomData
143        }
144    }
145
146    pub fn len(&self) -> usize { self.slice.len() }
147
148    pub fn as_slice<'a>(&'a self) -> &'a[Data] { self.slice }
149
150    pub fn iter<'a>(&'a self) -> slice::Iter<'a, Data> { self.slice.iter() }
151
152    pub fn ids<T:IntegerHandle>(&self) -> IdRange<ID::Unit, T> {
153        IdRange::new(FromIndex::from_index(0), FromIndex::from_index(self.len()))
154    }
155
156    pub fn nth(&self, idx: usize) -> &Data { &self.slice[idx] }
157}
158
159impl<'l, ID:Identifier, Data> ops::Index<ID> for IdSlice<'l, ID, Data> where Data:'l {
160    type Output = Data;
161    fn index<'a>(&'a self, id: ID) -> &'a Data { &self.slice[id.to_index()] }
162}
163
164
165
166pub struct MutIdSlice<'l, ID:Identifier, Data:'l> {
167    slice: &'l mut[Data],
168    _idtype: PhantomData<ID>
169}
170
171impl<'l, ID:Identifier, Data:'l> MutIdSlice<'l, ID, Data>{
172    pub fn new(slice: &'l mut[Data]) -> MutIdSlice<'l, ID, Data> {
173        MutIdSlice {
174            slice: slice,
175            _idtype: PhantomData
176        }
177    }
178
179    pub fn iter<'a>(&'a self) -> slice::Iter<'a, Data> { self.slice.iter() }
180    pub fn iter_mut<'a>(&'a mut self) -> slice::IterMut<'a, Data> { self.slice.iter_mut() }
181}
182
183impl<'l, ID:Identifier, Data:'l> IntoIterator for IdSlice<'l, ID, Data> {
184    type Item = &'l Data;
185    type IntoIter = slice::Iter<'l, Data>;
186    fn into_iter(self) -> slice::Iter<'l, Data> { self.slice.iter() }
187}
188
189impl<'l, ID:Identifier, Data:'l> IntoIterator for MutIdSlice<'l, ID, Data> {
190    type Item = &'l mut Data;
191    type IntoIter = slice::IterMut<'l, Data>;
192    fn into_iter(self) -> slice::IterMut<'l, Data> { self.slice.iter_mut() }
193}
194
195impl<'l, ID:Identifier, Data:'l> ops::Index<ID> for MutIdSlice<'l, ID, Data> {
196    type Output = Data;
197    fn index<'a>(&'a self, id: ID) -> &'a Data { &self.slice[id.to_index()] }
198}
199
200impl<'l, ID:Identifier, Data:'l> ops::IndexMut<ID> for MutIdSlice<'l, ID, Data> {
201    fn index_mut<'a>(&'a mut self, id: ID) -> &'a mut Data { &mut self.slice[id.to_index()] }
202}
203
204#[test]
205fn test_id_vector() {
206    use super::*;
207
208    #[derive(Debug)]
209    struct T;
210
211    fn id(i: u16) -> Id<T, u16> { Id::new(i) }
212
213    let mut v = IdVec::new();
214    let a = v.push(42 as u32);
215    assert_eq!(v[a], 42);
216    v.set(a, 0);
217    assert_eq!(v[a], 0);
218
219    v.set(id(10), 100);
220    assert_eq!(v[id(10)], 100);
221
222    v.set(id(5), 50);
223    assert_eq!(v[id(5)], 50);
224
225    v.set(id(20), 200);
226    assert_eq!(v[id(20)], 200);
227    assert_eq!(v.len(), 21);
228}
229
230#[test]
231fn test_id_vector_u32() {
232    let _: IdVec<u32, u32> = IdVec::new();
233    let _: IdVec<i32, i32> = IdVec::new();
234}
sid_vec/id_vector.rs

sid_vec/
id_vector.rs
