7 slice, |
7 slice, |
8 }; |
8 }; |
9 |
9 |
10 pub trait TypeTuple: Sized { |
10 pub trait TypeTuple: Sized { |
11 fn len() -> usize; |
11 fn len() -> usize; |
12 fn get_types(dest: &mut Vec<TypeId>); |
12 fn get_types(types: &mut Vec<TypeId>); |
13 unsafe fn iter<F: FnMut(Self)>(slices: &[*mut u8], count: usize, mut f: F); |
13 unsafe fn iter<F: FnMut(Self)>(slices: &[*mut u8], count: usize, mut f: F); |
14 } |
14 } |
15 |
15 |
16 macro_rules! type_tuple_impl { |
16 macro_rules! type_tuple_impl { |
17 ($($n: literal: $t: ident),+) => { |
17 ($($n: literal: $t: ident),+) => { |
135 self.types.iter().position(|id| *id == type_id) |
135 self.types.iter().position(|id| *id == type_id) |
136 } |
136 } |
137 |
137 |
138 fn move_between_blocks( |
138 fn move_between_blocks( |
139 &mut self, |
139 &mut self, |
140 from_block_index: u16, |
140 src_block_index: u16, |
141 from_index: u16, |
141 src_index: u16, |
142 to_block_index: u16, |
142 dest_block_index: u16, |
143 ) -> u16 { |
143 ) -> u16 { |
144 debug_assert!(from_block_index != to_block_index); |
144 debug_assert!(src_block_index != dest_block_index); |
145 let source_mask = self.block_masks[from_block_index as usize]; |
145 let src_mask = self.block_masks[src_block_index as usize]; |
146 let destination_mask = self.block_masks[to_block_index as usize]; |
146 let dest_mask = self.block_masks[dest_block_index as usize]; |
147 debug_assert!(source_mask & destination_mask == source_mask); |
147 debug_assert!(src_mask & dest_mask == src_mask); |
148 |
148 |
149 let source = &self.blocks[from_block_index as usize]; |
149 let src_block = &self.blocks[src_block_index as usize]; |
150 let destination = &self.blocks[to_block_index as usize]; |
150 let dest_block = &self.blocks[dest_block_index as usize]; |
151 debug_assert!(from_index < source.elements_count); |
151 debug_assert!(src_index < src_block.elements_count); |
152 debug_assert!(!destination.is_full()); |
152 debug_assert!(!dest_block.is_full()); |
153 |
153 |
154 let to_index = destination.elements_count; |
154 let dest_index = dest_block.elements_count; |
155 for i in 0..self.types.len() { |
155 for i in 0..self.types.len() { |
156 if source_mask & 1 << i as u64 != 0 { |
156 if src_mask & (1 << i as u64) != 0 { |
|
157 let size = self.element_sizes[i]; |
|
158 let src_ptr = src_block.component_blocks[i].unwrap().as_ptr(); |
|
159 let dest_ptr = dest_block.component_blocks[i].unwrap().as_ptr(); |
157 unsafe { |
160 unsafe { |
158 copy_nonoverlapping( |
161 copy_nonoverlapping( |
159 source.component_blocks[i] |
162 src_ptr.add((src_index * size) as usize), |
160 .unwrap() |
163 dest_ptr.add((dest_index * size) as usize), |
161 .as_ptr() |
164 size as usize, |
162 .add((from_index * self.element_sizes[i]) as usize), |
|
163 destination.component_blocks[i] |
|
164 .unwrap() |
|
165 .as_ptr() |
|
166 .add((to_index * self.element_sizes[i]) as usize), |
|
167 self.element_sizes[i] as usize, |
|
168 ); |
165 ); |
169 } |
166 if src_index < src_block.elements_count - 1 { |
170 } |
167 copy_nonoverlapping( |
171 } |
168 src_ptr.add((size * (src_block.elements_count - 1)) as usize), |
172 self.blocks[from_block_index as usize].elements_count -= 1; |
169 src_ptr.add((size * src_index) as usize), |
173 let destination = &mut self.blocks[to_block_index as usize]; |
170 size as usize, |
174 destination.elements_count += 1; |
171 ); |
175 destination.elements_count - 1 |
172 } |
|
173 } |
|
174 } |
|
175 } |
|
176 self.blocks[src_block_index as usize].elements_count -= 1; |
|
177 let dest_block = &mut self.blocks[dest_block_index as usize]; |
|
178 dest_block.elements_count += 1; |
|
179 dest_block.elements_count - 1 |
176 } |
180 } |
177 |
181 |
178 fn add_to_block<T: Clone>(&mut self, block_index: u16, value: &T) -> u16 { |
182 fn add_to_block<T: Clone>(&mut self, block_index: u16, value: &T) -> u16 { |
179 debug_assert!(self.block_masks[block_index as usize].count_ones() == 1); |
183 debug_assert!(self.block_masks[block_index as usize].count_ones() == 1); |
180 |
184 |
267 |
271 |
268 pub fn remove<T: 'static>(&mut self, gear_id: GearId) { |
272 pub fn remove<T: 'static>(&mut self, gear_id: GearId) { |
269 if let Some(type_index) = self.get_type_index::<T>() { |
273 if let Some(type_index) = self.get_type_index::<T>() { |
270 let entry = self.lookup[gear_id.get() as usize - 1]; |
274 let entry = self.lookup[gear_id.get() as usize - 1]; |
271 if let Some(index) = entry.index { |
275 if let Some(index) = entry.index { |
272 let destination_mask = |
276 let dest_mask = |
273 self.block_masks[entry.block_index as usize] & !(1 << type_index as u64); |
277 self.block_masks[entry.block_index as usize] & !(1 << type_index as u64); |
274 |
278 |
275 if destination_mask == 0 { |
279 if dest_mask == 0 { |
276 self.remove_all(gear_id) |
280 self.remove_all(gear_id) |
277 } else { |
281 } else { |
278 let destination_block_index = self.ensure_block(destination_mask); |
282 let dest_block_index = self.ensure_block(dest_mask); |
279 self.move_between_blocks( |
283 self.move_between_blocks(entry.block_index, index.get() - 1, dest_block_index); |
280 entry.block_index, |
|
281 index.get() - 1, |
|
282 destination_block_index, |
|
283 ); |
|
284 } |
284 } |
285 } |
285 } |
286 } else { |
286 } else { |
287 panic!("Unregistered type") |
287 panic!("Unregistered type") |
288 } |
288 } |
318 let mut type_indices = vec![-1i8; arg_types.len()]; |
318 let mut type_indices = vec![-1i8; arg_types.len()]; |
319 let mut selector = 0u64; |
319 let mut selector = 0u64; |
320 |
320 |
321 for (arg_index, type_id) in arg_types.iter().enumerate() { |
321 for (arg_index, type_id) in arg_types.iter().enumerate() { |
322 match self.types.iter().position(|t| t == type_id) { |
322 match self.types.iter().position(|t| t == type_id) { |
323 Some(i) if selector & 1 << i as u64 != 0 => panic!("Duplicate type"), |
323 Some(i) if selector & (1 << i as u64) != 0 => panic!("Duplicate type"), |
324 Some(i) => { |
324 Some(i) => { |
325 type_indices[arg_index] = i as i8; |
325 type_indices[arg_index] = i as i8; |
326 selector |= 1 << i as u64; |
326 selector |= 1 << i as u64; |
327 } |
327 } |
328 None => panic!("Unregistered type"), |
328 None => panic!("Unregistered type"), |