sized_chunks/sized_chunk/
refpool.rs1use core::mem::MaybeUninit;
2
3use ::refpool::{PoolClone, PoolDefault};
4
5use crate::Chunk;
6
7impl<A, const N: usize> PoolDefault for Chunk<A, N> {
8 unsafe fn default_uninit(target: &mut MaybeUninit<Self>) {
9 let ptr = target.as_mut_ptr();
10 let left_ptr: *mut usize = &mut (*ptr).left;
11 let right_ptr: *mut usize = &mut (*ptr).right;
12 left_ptr.write(0);
13 right_ptr.write(0);
14 }
15}
16
17impl<A, const N: usize> PoolClone for Chunk<A, N>
18where
19 A: Clone,
20{
21 unsafe fn clone_uninit(&self, target: &mut MaybeUninit<Self>) {
22 let ptr = target.as_mut_ptr();
23 let left_ptr: *mut usize = &mut (*ptr).left;
24 let right_ptr: *mut usize = &mut (*ptr).right;
25 let data_ptr: *mut _ = &mut (*ptr).data;
26 let data_ptr: *mut A = (*data_ptr).as_mut_ptr().cast();
27 left_ptr.write(self.left);
28 right_ptr.write(self.right);
29 for index in self.left..self.right {
30 data_ptr.add(index).write((*self.ptr(index)).clone());
31 }
32 }
33}
34
35#[cfg(test)]
36mod test {
37 use super::*;
38 use ::refpool::{Pool, PoolRef};
39 use std::iter::FromIterator;
40
41 #[test]
42 fn default_and_clone() {
43 let pool: Pool<Chunk<usize, 64>> = Pool::new(16);
44 let mut ref1 = PoolRef::default(&pool);
45 {
46 let chunk = PoolRef::make_mut(&pool, &mut ref1);
47 chunk.push_back(1);
48 chunk.push_back(2);
49 chunk.push_back(3);
50 }
51 let ref2 = PoolRef::cloned(&pool, &ref1);
52 let ref3 = PoolRef::clone_from(&pool, &Chunk::from_iter(1..=3));
53 assert_eq!(Chunk::<usize, 64>::from_iter(1..=3), *ref1);
54 assert_eq!(Chunk::<usize, 64>::from_iter(1..=3), *ref2);
55 assert_eq!(Chunk::<usize, 64>::from_iter(1..=3), *ref3);
56 assert_eq!(ref1, ref2);
57 assert_eq!(ref1, ref3);
58 assert_eq!(ref2, ref3);
59 assert!(!PoolRef::ptr_eq(&ref1, &ref2));
60 }
61}