Struct easy_mmap::EasyMmap

pub struct EasyMmap<'a, T> { /* private fields */ }

The main abstraction over the mmap crate. Owns a memory map and provides simplified and safe access to this memory region. Also provides some additional features such as iterators over the data.

Implementations

impl<'a, T> EasyMmap<'a, T> where
    T: Copy, 

pub fn len(&self) -> usize

How many elements can be stored in the memory map.

pub fn iter(&self) -> Iter<'_, T>

Returns a read-only iterator over the elements of the memory map.

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns a mutable iterator over the elements of the memory map.

pub fn par_iter(&self) -> impl ParallelIterator<Item = &T> where
    T: Send + Sync, 

Returns a parallel iterator over the elements of the memory map.

pub fn par_iter_mut(&mut self) -> impl ParallelIterator<Item = &mut T> where
    T: Send + Sync, 

Returns a mutable parallel iterator over the elements of the memory map.

pub fn get_data_as_slice(&self) -> &[T]

Returns a read-only slice of the memory map data.

pub fn get_data_as_slice_mut(&mut self) -> &mut [T]

Returns a mutable slice of the memory map data.

pub fn fill(&mut self, f: impl Fn(usize) -> T)

Convenience method for filling the memory map with a custom function Example:

let mut mmap = easy_mmap::EasyMmapBuilder::new()
                           .readable()
                           .writable()
                           .capacity(5)
                           .build();

mmap.fill(|i| i as u32);
assert_eq!(mmap.get_data_as_slice(), &[0, 1, 2, 3, 4]);

Trait Implementations

impl<'a, T> Index<usize> for EasyMmap<'a, T> where
    T: Copy, 

The structure can be indexed similarly to an array. Example:

let mut mmap = easy_mmap::EasyMmapBuilder::new()
                    .options(&[
                        mmap::MapOption::MapWritable,
                        mmap::MapOption::MapReadable,
                    ])
                    .capacity(10)
                    .build();
mmap[0] = 1;
println!("{}", mmap[0]);

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, T> IndexMut<usize> for EasyMmap<'a, T> where
    T: Copy, 

The structure can be indexed an array or slice. See the Index trait for an example.

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.