vendor/sized-chunks/src/ring_buffer/refpool.rs

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