5 num::NonZeroU16, |
5 num::NonZeroU16, |
6 ptr::NonNull, |
6 ptr::NonNull, |
7 slice, |
7 slice, |
8 }; |
8 }; |
9 |
9 |
10 pub trait TypeTuple: Sized { |
10 pub unsafe trait TypeTuple: Sized { |
11 fn len() -> usize; |
11 fn len() -> usize; |
12 fn get_types(dest: &mut Vec<TypeId>); |
12 fn get_types(dest: &mut Vec<TypeId>); |
13 unsafe fn iter<F>(slices: &[NonNull<u8>], count: usize, f: F) |
13 unsafe fn iter<F>(slices: &[NonNull<u8>], count: usize, f: F) |
14 where |
14 where |
15 F: Fn(Self); |
15 F: Fn(Self); |
16 } |
16 } |
17 |
17 |
18 impl<T: 'static> TypeTuple for (&T,) { |
18 unsafe impl<T: 'static> TypeTuple for (&T,) { |
19 fn len() -> usize { |
19 fn len() -> usize { |
20 1 |
20 1 |
21 } |
21 } |
22 |
22 |
23 fn get_types(dest: &mut Vec<TypeId>) { |
23 fn get_types(dest: &mut Vec<TypeId>) { |
121 for i in 0..64 { |
121 for i in 0..64 { |
122 unimplemented!() |
122 unimplemented!() |
123 } |
123 } |
124 } |
124 } |
125 |
125 |
126 fn add_to_block<T>(&mut self, block_index: u16, value: &T) { |
126 fn add_to_block<T: Clone>(&mut self, block_index: u16, value: &T) { |
127 unimplemented!() |
127 debug_assert!(self.block_masks[block_index as usize].count_ones() == 1); |
|
128 |
|
129 let block = &mut self.blocks[block_index as usize]; |
|
130 debug_assert!(block.elements_count < block.max_elements); |
|
131 |
|
132 unsafe { |
|
133 let slice = slice::from_raw_parts_mut( |
|
134 block.data.as_mut_ptr() as *mut T, |
|
135 block.max_elements as usize, |
|
136 ); |
|
137 *slice.get_unchecked_mut(block.elements_count as usize) = value.clone(); |
|
138 }; |
|
139 block.elements_count += 1; |
128 } |
140 } |
129 |
141 |
130 fn remove_from_block(&mut self, block_index: u16, index: u16) { |
142 fn remove_from_block(&mut self, block_index: u16, index: u16) { |
131 unimplemented!() |
143 let block = &mut self.blocks[block_index as usize]; |
|
144 debug_assert!(index < block.elements_count); |
|
145 |
|
146 for (i, size) in self.element_sizes.iter().cloned().enumerate() { |
|
147 if index < block.elements_count - 1 { |
|
148 if let Some(mut ptr) = block.blocks[i] { |
|
149 unsafe { |
|
150 std::ptr::copy_nonoverlapping( |
|
151 ptr.as_ptr() |
|
152 .add((size * (block.elements_count - 1)) as usize), |
|
153 ptr.as_ptr().add((size * index) as usize), |
|
154 size as usize, |
|
155 ); |
|
156 } |
|
157 } |
|
158 } |
|
159 } |
|
160 block.elements_count -= 1; |
132 } |
161 } |
133 |
162 |
134 #[inline] |
163 #[inline] |
135 fn ensure_group(&mut self, mask: u64) -> u16 { |
164 fn ensure_group(&mut self, mask: u64) -> u16 { |
136 if let Some(index) = self |
165 if let Some(index) = self |
176 } |
205 } |
177 } |
206 } |
178 } |
207 } |
179 |
208 |
180 pub fn register<T: 'static>(&mut self) { |
209 pub fn register<T: 'static>(&mut self) { |
181 assert!(!std::mem::needs_drop::<T>()); |
210 debug_assert!(!std::mem::needs_drop::<T>()); |
182 assert!(self.types.len() <= 64); |
211 debug_assert!(self.types.len() <= 64); |
183 assert!(size_of::<T>() <= u16::max_value() as usize); |
212 debug_assert!(size_of::<T>() <= u16::max_value() as usize); |
184 |
213 |
185 let id = TypeId::of::<T>(); |
214 let id = TypeId::of::<T>(); |
186 if !self.types.contains(&id) { |
215 if !self.types.contains(&id) { |
187 self.element_sizes[self.types.len()] = size_of::<T>() as u16; |
216 self.element_sizes[self.types.len()] = size_of::<T>() as u16; |
188 self.types.push(id); |
217 self.types.push(id); |
200 } |
229 } |
201 |
230 |
202 pub fn iter<T: TypeTuple + 'static, F: Fn(T) + Copy>(&self, f: F) { |
231 pub fn iter<T: TypeTuple + 'static, F: Fn(T) + Copy>(&self, f: F) { |
203 let mut types = vec![]; |
232 let mut types = vec![]; |
204 T::get_types(&mut types); |
233 T::get_types(&mut types); |
|
234 debug_assert!(types.iter().all(|t| self.types.contains(t))); |
|
235 |
205 let types_count = types.len(); |
236 let types_count = types.len(); |
206 |
|
207 let selector = self.create_selector(&types); |
237 let selector = self.create_selector(&types); |
|
238 |
208 for (block_index, mask) in self.block_masks.iter().enumerate() { |
239 for (block_index, mask) in self.block_masks.iter().enumerate() { |
209 if mask & selector == selector { |
240 if mask & selector == selector { |
210 let block = &self.blocks[block_index]; |
241 let block = &self.blocks[block_index]; |
211 for element_index in 0..block.max_elements { |
242 for element_index in 0..block.max_elements { |
212 unimplemented!() |
243 unsafe { |
|
244 T::iter(unimplemented!(), block.elements_count as usize, f); |
|
245 } |
213 } |
246 } |
214 } |
247 } |
215 } |
248 } |
216 } |
249 } |
217 } |
250 } |