Struct ReadWriteMmap

pub struct ReadWriteMmap<'a> { /* private fields */ }

A read-write memory mapping that allows shared access to a file’s contents.

This struct provides a safe wrapper around platform-specific memory mapping implementations, allowing read and write access to a file’s contents through memory mapping. The mapping can be created with a specific offset and length.

The mapping cannot outlive the file handle it was created from.

Implementations

impl<'a> ReadWriteMmap<'a>

pub fn new( handle: &'a ReadWriteFileHandle, offset: u64, len: usize, ) -> Result<Self, MmapError>

Creates a new read-write memory mapping for the specified file handle.

Arguments

• handle - The file handle to create the mapping from
• offset - The offset into the file where the mapping should begin
• len - The length of the mapping in bytes

Errors

Returns a MmapError if:

• The mapping cannot be created
• The length is zero
• The offset and length would exceed the file size
• The system cannot allocate the required resources

pub fn as_slice(&self) -> &'a [u8]

Returns a slice of the mapped memory. The lifetime of the slice is the same as the mapping.

pub fn as_mut_slice(&mut self) -> &'a mut [u8]

Returns a mutable slice of the mapped memory. The lifetime of the slice is the same as the mapping.

pub fn data(&self) -> *mut u8

Returns a raw pointer to the mapped memory.

The returned pointer is adjusted for the requested offset, accounting for any page alignment requirements.

Safety

The caller must ensure that the memory is accessed within the bounds of the mapping. The caller must also ensure the pointer does not outlast the lifetime of the mapping. It is recommended you use Self::as_slice or Self::as_mut_slice instead for compiler enforced safety.

pub fn len(&self) -> usize

Returns the length of the mapped region in bytes.

This returns the originally requested length, not including any padding added for page alignment.

pub fn is_empty(&self) -> bool

Returns whether the mapping is empty (zero length).

pub fn advise(&self, advice: MemoryAdvice)

Provides advice to the operating system about how the memory mapping will be accessed.

Arguments

• advice - Bit flags indicating the expected access patterns for this memory region

Note

This is a hint to the operating system and may be ignored. Not all advice types are supported on all platforms. On Windows, only MemoryAdvice::WILL_NEED has an effect. Multiple advice flags can be combined using bitwise operations.

Trait Implementations

impl<'a> Clone for ReadWriteMmap<'a>

fn clone(&self) -> ReadWriteMmap<'a>

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for ReadWriteMmap<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Ord for ReadWriteMmap<'a>

fn cmp(&self, other: &ReadWriteMmap<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for ReadWriteMmap<'a>

fn eq(&self, other: &ReadWriteMmap<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd for ReadWriteMmap<'a>

fn partial_cmp(&self, other: &ReadWriteMmap<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Eq for ReadWriteMmap<'a>

impl<'a> StructuralPartialEq for ReadWriteMmap<'a>