use std::ops::{Deref, DerefMut}; pub struct SharedBuffer { pub ptr: *mut T, len: usize, } impl SharedBuffer { pub fn new(ptr: *mut T, len: usize) -> Self { Self { ptr, len } } } impl From<&[T]> for SharedBuffer { fn from(slice: &[T]) -> Self { Self { ptr: slice.as_ptr() as *mut T, len: slice.len(), } } } impl From<&[T; K]> for SharedBuffer { fn from(arr: &[T; K]) -> Self { Self { ptr: arr.as_ptr() as *mut T, len: K, } } } impl AsRef<[T]> for SharedBuffer { fn as_ref(&self) -> &[T] { unsafe { std::slice::from_raw_parts(self.ptr, self.len) } } } impl AsMut<[T]> for SharedBuffer { fn as_mut(&mut self) -> &mut [T] { unsafe { std::slice::from_raw_parts_mut(self.ptr, self.len) } } } impl Deref for SharedBuffer { type Target = [T]; fn deref(&self) -> &Self::Target { self.as_ref() } } impl DerefMut for SharedBuffer { fn deref_mut(&mut self) -> &mut Self::Target { self.as_mut() } } #[cfg(test)] mod test { use super::SharedBuffer; use std::{sync::Arc, time::Duration}; #[test] fn can_mut_immutable() { let data = [0u8; 256]; let mut share: SharedBuffer = data.as_ref().into(); share.as_mut()[0] = 255; assert_eq!(data[0], 255); } #[test] fn can_mut_immutable_multithread() { let data = [0u8; 256]; let arc_data = Arc::new(data); let arc_clone = Arc::clone(&arc_data); let handle = std::thread::spawn(move || { std::thread::sleep(Duration::from_millis(100)); let mut share: SharedBuffer = arc_clone.as_ref().into(); share[0] = 255; std::thread::sleep(Duration::from_millis(150)); }); std::thread::sleep(Duration::from_millis(200)); assert_eq!(arc_data[0], 255); handle.join().unwrap(); } }