138 let mut address = unsafe { |
138 let mut address = unsafe { |
139 data.as_mut_ptr() |
139 data.as_mut_ptr() |
140 .add(size_of::<GearId>() * max_elements as usize) |
140 .add(size_of::<GearId>() * max_elements as usize) |
141 }; |
141 }; |
142 |
142 |
143 for i in 0..element_sizes.len() { |
143 let mut mask_bits = mask; |
144 if mask & (1 << i as u64) != 0 { |
144 while mask_bits != 0 { |
145 unsafe { |
145 let i = mask_bits.trailing_zeros() as usize; |
146 address = address.add(address.align_offset(element_alignments[i] as usize)); |
146 |
147 blocks[i] = Some(NonNull::new_unchecked(address)); |
147 unsafe { |
148 address = address.add(element_sizes[i] as usize * max_elements as usize) |
148 address = address.add(address.align_offset(element_alignments[i] as usize)); |
149 }; |
149 blocks[i] = Some(NonNull::new_unchecked(address)); |
150 } |
150 address = address.add(element_sizes[i] as usize * max_elements as usize) |
|
151 }; |
|
152 |
|
153 mask_bits &= mask_bits - 1; |
151 } |
154 } |
152 |
155 |
153 Self { |
156 Self { |
154 elements_count: 0, |
157 elements_count: 0, |
155 max_elements, |
158 max_elements, |
157 component_blocks: blocks, |
160 component_blocks: blocks, |
158 element_sizes: Box::from(element_sizes), |
161 element_sizes: Box::from(element_sizes), |
159 } |
162 } |
160 } |
163 } |
161 |
164 |
|
165 #[inline] |
162 fn gear_ids(&self) -> &[GearId] { |
166 fn gear_ids(&self) -> &[GearId] { |
163 unsafe { |
167 unsafe { |
164 slice::from_raw_parts( |
168 slice::from_raw_parts( |
165 self.data.as_ptr() as *const GearId, |
169 self.data.as_ptr() as *const GearId, |
166 self.max_elements as usize, |
170 self.max_elements as usize, |
167 ) |
171 ) |
168 } |
172 } |
169 } |
173 } |
170 |
174 |
|
175 #[inline] |
171 fn gear_ids_mut(&mut self) -> &mut [GearId] { |
176 fn gear_ids_mut(&mut self) -> &mut [GearId] { |
172 unsafe { |
177 unsafe { |
173 slice::from_raw_parts_mut( |
178 slice::from_raw_parts_mut( |
174 self.data.as_mut_ptr() as *mut GearId, |
179 self.data.as_mut_ptr() as *mut GearId, |
175 self.max_elements as usize, |
180 self.max_elements as usize, |
176 ) |
181 ) |
177 } |
182 } |
178 } |
183 } |
179 |
184 |
|
185 #[inline] |
180 fn is_full(&self) -> bool { |
186 fn is_full(&self) -> bool { |
181 self.elements_count == self.max_elements |
187 self.elements_count == self.max_elements |
182 } |
188 } |
183 } |
189 } |
184 |
190 |
273 let dest_block = &self.blocks[dest_block_index as usize]; |
279 let dest_block = &self.blocks[dest_block_index as usize]; |
274 debug_assert!(src_index < src_block.elements_count); |
280 debug_assert!(src_index < src_block.elements_count); |
275 debug_assert!(!dest_block.is_full()); |
281 debug_assert!(!dest_block.is_full()); |
276 |
282 |
277 let dest_index = dest_block.elements_count; |
283 let dest_index = dest_block.elements_count; |
278 for i in 0..self.types.len() { |
284 |
279 if src_mask.type_mask & (1 << i as u64) != 0 { |
285 let mut type_mask = src_mask.type_mask; |
280 let size = self.element_sizes[i]; |
286 while type_mask != 0 { |
281 let src_ptr = src_block.component_blocks[i].unwrap().as_ptr(); |
287 let i = type_mask.trailing_zeros() as usize; |
282 let dest_ptr = dest_block.component_blocks[i].unwrap().as_ptr(); |
288 |
283 unsafe { |
289 let size = self.element_sizes[i]; |
|
290 let src_ptr = src_block.component_blocks[i].unwrap().as_ptr(); |
|
291 let dest_ptr = dest_block.component_blocks[i].unwrap().as_ptr(); |
|
292 unsafe { |
|
293 copy_nonoverlapping( |
|
294 src_ptr.add((src_index * size) as usize), |
|
295 dest_ptr.add((dest_index * size) as usize), |
|
296 size as usize, |
|
297 ); |
|
298 if src_index < src_block.elements_count - 1 { |
284 copy_nonoverlapping( |
299 copy_nonoverlapping( |
285 src_ptr.add((src_index * size) as usize), |
300 src_ptr.add((size * (src_block.elements_count - 1)) as usize), |
286 dest_ptr.add((dest_index * size) as usize), |
301 src_ptr.add((size * src_index) as usize), |
287 size as usize, |
302 size as usize, |
288 ); |
303 ); |
289 if src_index < src_block.elements_count - 1 { |
304 } |
290 copy_nonoverlapping( |
305 } |
291 src_ptr.add((size * (src_block.elements_count - 1)) as usize), |
306 |
292 src_ptr.add((size * src_index) as usize), |
307 type_mask &= type_mask - 1; |
293 size as usize, |
|
294 ); |
|
295 } |
|
296 } |
|
297 } |
|
298 } |
308 } |
299 |
309 |
300 let src_block = &mut self.blocks[src_block_index as usize]; |
310 let src_block = &mut self.blocks[src_block_index as usize]; |
301 let gear_id = src_block.gear_ids()[src_index as usize]; |
311 let gear_id = src_block.gear_ids()[src_index as usize]; |
302 |
312 |