Struct mmap_wrapper::MmapMutWrapper

pub struct MmapMutWrapper<T> { /* private fields */ }

MmapMutWrapper

this is identical to MmapWrapper but returns a mutable reference instead.

this is a helpful wrapper for this use case:

 use mmap_wrapper::MmapMutWrapper;

 // structs musthave a well defined layout,
 // generally want them to be transparent or repr(C)
 #[repr(C)]  
 struct MyStruct {
    thing1: i32,
    thing2: f64,
 }

 let f = std::fs::File::options()
     .read(true)
     .write(true)
     .create(true)
     .truncate(false)
     .open("/tmp/mystruct-mmap-test.bin")
     .unwrap();
   
 let _ = f.set_len(std::mem::size_of::<MyStruct>() as u64);

 let m = unsafe {
     memmap2::MmapMut::map_mut(&f).unwrap()
 };

 let mut m_wrapper = MmapMutWrapper::<MyStruct>::new(m);
 let mmap_backed_mystruct = unsafe {
    m_wrapper.get_inner()
 };

 mmap_backed_mystruct.thing1 = 123;

Implementations

impl<T> MmapMutWrapper<T>

pub fn new(m: MmapMut) -> MmapMutWrapper<T>

pub unsafe fn get_inner<'a>(&mut self) -> &'a mut T

Safety

the backing mmap pointer must point to valid memory for type T [T likely has to be repr(C)]

Trait Implementations

impl<T> From<MmapMut> for MmapMutWrapper<T>

fn from(m: MmapMut) -> MmapMutWrapper<T>

Converts to this type from the input type.