Struct fmmap::raw::sync::MemoryMmapFileMut

pub struct MemoryMmapFileMut { /* private fields */ }

Available on crate feature sync only.

Use BytesMut to mock a mmap, which is useful for test and in-memory storage engine.

Notes

MemoryMmapFileMut mocks a mmap behaviour, which means when writing to it, it will not auto-grow its size, so if you want to grow the size of the MemoryMmapFileMut, you need to truncate it first.

If you want the auto-grow functionality, please use BytesMut.

Implementations

impl MemoryMmapFileMut

pub fn new<P: AsRef<Path>>(path: P) -> Self

Create a MemoryMmapFileMut

Examples

use fmmap::raw::MemoryMmapFileMut;

MemoryMmapFileMut::new("foo.mem");

pub fn with_capacity<P: AsRef<Path>>(path: P, cap: usize) -> Self

Create a MemoryMmapFileMutwith capacity

Examples

use fmmap::raw::MemoryMmapFileMut;

MemoryMmapFileMut::with_capacity("foo.mem", 1000);

pub fn from_vec<P: AsRef<Path>>(path: P, src: Vec<u8>) -> Self

Create a MemoryMmapFileMut from Vec

Examples

use fmmap::raw::MemoryMmapFileMut;

let data = (0..=255u8).collect::<Vec<_>>();
MemoryMmapFileMut::from_vec("foo.mem", data);

pub fn from_string<P: AsRef<Path>>(path: P, src: String) -> Self

Create a MemoryMmapFileMut from String

Examples

use fmmap::raw::MemoryMmapFileMut;

let data: &'static str = "some data...";
MemoryMmapFileMut::from_string("foo.mem", data.to_string());

pub fn from_str<P: AsRef<Path>>(path: P, src: &'static str) -> Self

Create a MemoryMmapFileMut from static str

Examples

use bytes::Bytes;
use fmmap::raw::MemoryMmapFileMut;

let data: &'static str = "some data...";
MemoryMmapFileMut::from_str("foo.mem", data);

pub fn from_slice<P: AsRef<Path>>(path: P, src: &[u8]) -> Self

Create a MemoryMmapFileMut by from slice

Examples

use fmmap::raw::MemoryMmapFileMut;

MemoryMmapFileMut::from_slice("foo.mem", "some data...".as_bytes());

pub fn into_bytes_mut(self) -> BytesMut

Returns the inner mutable bytes

Examples

use bytes::BytesMut;
use fmmap::raw::MemoryMmapFileMut;

let b1 = MemoryMmapFileMut::from_slice("foo.mem", "some data...".as_bytes()).into_bytes_mut();
assert_eq!(b1, BytesMut::from("some data...".as_bytes()));

pub fn into_bytes(self) -> Bytes

Returns the inner bytes

Examples

use bytes::Bytes;
use fmmap::raw::MemoryMmapFileMut;

let b1 = MemoryMmapFileMut::from_slice("foo.mem", "some data...".as_bytes()).into_bytes();
assert_eq!(b1, Bytes::copy_from_slice("some data...".as_bytes()));

pub fn freeze(self) -> MemoryMmapFile

Make the memory mmap file immutable

Examples

use bytes::Bytes;
use fmmap::MmapFileExt;
use fmmap::raw::{MemoryMmapFileMut,MemoryMmapFile};

let b1 = MemoryMmapFileMut::from_string("foo.mem", "some data...".to_string()).freeze();
let b2 = MemoryMmapFile::from_string("foo.mem", "some data...".to_string());
assert!(!b1.is_exec());
assert_eq!(b1.len(), b2.len());
assert_eq!(b1.as_slice(), b2.as_slice());
assert_eq!(b1.path_string(), b2.path_string());

Trait Implementations

impl Clone for MemoryMmapFileMut

fn clone(&self) -> MemoryMmapFileMut

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<MemoryMmapFileMut> for MmapFileMut

fn from(file: MemoryMmapFileMut) -> Self

Converts to this type from the input type.

impl MmapFileExt for MemoryMmapFileMut

fn len(&self) -> usize

Returns the current mmap length

fn as_slice(&self) -> &[u8]

Returns the underlying slice of the mmap

fn path(&self) -> &Path

Returns the path of the inner file.

fn is_exec(&self) -> bool

Whether the mmap is executable.

fn metadata(&self) -> Result<MetaData>

Returns the metadata of file metadata

fn lock_exclusive(&self) -> Result<()>

Locks the file for shared usage, blocking if the file is currently locked exclusively.

fn lock_shared(&self) -> Result<()>

Locks the file for exclusive usage, blocking if the file is currently locked.

fn try_lock_exclusive(&self) -> Result<()>

Locks the file for shared usage, or returns a an error if the file is currently locked (see lock_contended_error).

fn try_lock_shared(&self) -> Result<()>

Locks the file for shared usage, or returns a an error if the file is currently locked (see lock_contended_error).Locks the file for shared usage, or returns a an error if the file is currently locked (see lock_contended_error).

fn unlock(&self) -> Result<()>

Unlocks the file.

fn is_empty(&self) -> bool

Returns the mmap is empty of not.

fn slice(&self, offset: usize, sz: usize) -> &[u8]

slice returns data starting from offset off of size sz.

fn bytes(&self, offset: usize, sz: usize) -> Result<&[u8]>

bytes returns data starting from offset off of size sz.

fn path_buf(&self) -> PathBuf

Returns the path buf of the inner file.

fn path_lossy(&self) -> Cow<'_, str>

Returns the path lossy string of the inner file.

fn path_string(&self) -> String

Returns the path string of the inner file.

fn copy_all_to_vec(&self) -> Vec<u8>

Copy the content of the mmap file to Vec

fn copy_range_to_vec(&self, offset: usize, len: usize) -> Vec<u8>

Copy a range of content of the mmap file to Vec

fn write_all_to_new_file<P: AsRef<Path>>(&self, new_file_path: P) -> Result<()>

Write the content of the mmap file to a new file.

fn write_range_to_new_file<P: AsRef<Path>>(
    &self,
    new_file_path: P,
    offset: usize,
    len: usize
) -> Result<()>

Write a range of content of the mmap file to new file.

fn reader(&self, offset: usize) -> Result<MmapFileReader<'_>>

Returns a MmapFileReader which helps read data from mmap like a normal File.

fn range_reader(&self, offset: usize, len: usize) -> Result<MmapFileReader<'_>>

Returns a MmapFileReader base on the given offset and len, which helps read data from mmap like a normal File.

fn read(&self, dst: &mut [u8], offset: usize) -> usize

Read bytes to the dst buf from the offset, returns how many bytes read.

fn read_exact(&self, dst: &mut [u8], offset: usize) -> Result<()>

Read the exact number of bytes required to fill buf.

fn read_i8(&self, offset: usize) -> Result<i8>

Read a signed 8 bit integer from offset.

fn read_i16(&self, offset: usize) -> Result<i16>

Read a signed 16 bit integer from offset in big-endian byte order.

fn read_i16_le(&self, offset: usize) -> Result<i16>

Read a signed 16 bit integer from offset in little-endian byte order.

fn read_isize(&self, offset: usize) -> Result<isize>

Read a signed integer from offset in big-endian byte order.

fn read_isize_le(&self, offset: usize) -> Result<isize>

Read a signed integer from offset in little-endian byte order.

fn read_i32(&self, offset: usize) -> Result<i32>

Read a signed 32 bit integer from offset in big-endian byte order.

fn read_i32_le(&self, offset: usize) -> Result<i32>

Read a signed 32 bit integer from offset in little-endian byte order.

fn read_i64(&self, offset: usize) -> Result<i64>

Read a signed 64 bit integer from offset in big-endian byte order.

fn read_i64_le(&self, offset: usize) -> Result<i64>

Read a signed 64 bit integer from offset in little-endian byte order.

fn read_i128(&self, offset: usize) -> Result<i128>

Read a signed 128 bit integer from offset in big-endian byte order.

fn read_i128_le(&self, offset: usize) -> Result<i128>

Read a signed 128 bit integer from offset in little-endian byte order.

fn read_u8(&self, offset: usize) -> Result<u8>

Read an unsigned 8 bit integer from offset.

fn read_u16(&self, offset: usize) -> Result<u16>

Read an unsigned 16 bit integer from offset in big-endian.

fn read_u16_le(&self, offset: usize) -> Result<u16>

Read an unsigned 16 bit integer from offset in little-endian.

fn read_usize(&self, offset: usize) -> Result<usize>

Read an unsigned integer from offset in big-endian byte order.

fn read_usize_le(&self, offset: usize) -> Result<usize>

Read an unsigned integer from offset in little-endian byte order.

fn read_u32(&self, offset: usize) -> Result<u32>

Read an unsigned 32 bit integer from offset in big-endian.

fn read_u32_le(&self, offset: usize) -> Result<u32>

Read an unsigned 32 bit integer from offset in little-endian.

fn read_u64(&self, offset: usize) -> Result<u64>

Read an unsigned 64 bit integer from offset in big-endian.

fn read_u64_le(&self, offset: usize) -> Result<u64>

Read an unsigned 64 bit integer from offset in little-endian.

fn read_u128(&self, offset: usize) -> Result<u128>

Read an unsigned 128 bit integer from offset in big-endian.

fn read_u128_le(&self, offset: usize) -> Result<u128>

Read an unsigned 128 bit integer from offset in little-endian.

fn read_f32(&self, offset: usize) -> Result<f32>

Read an IEEE754 single-precision (4 bytes) floating point number from offset in big-endian byte order.

fn read_f32_le(&self, offset: usize) -> Result<f32>

Read an IEEE754 single-precision (4 bytes) floating point number from offset in little-endian byte order.

fn read_f64(&self, offset: usize) -> Result<f64>

Read an IEEE754 single-precision (8 bytes) floating point number from offset in big-endian byte order.

fn read_f64_le(&self, offset: usize) -> Result<f64>

Read an IEEE754 single-precision (8 bytes) floating point number from offset in little-endian byte order.

impl MmapFileMutExt for MemoryMmapFileMut

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

Returns the mutable underlying slice of the mmap

fn is_cow(&self) -> bool

Whether mmap is copy on write

fn flush(&self) -> Result<()>

Flushes outstanding memory map modifications to disk (if the inner is a real file).

fn flush_async(&self) -> Result<()>

Asynchronously flushes outstanding memory map modifications to disk(if the inner is a real file).

fn flush_range(&self, _offset: usize, _len: usize) -> Result<()>

Flushes outstanding memory map modifications in the range to disk(if the inner is a real file).

fn flush_async_range(&self, _offset: usize, _len: usize) -> Result<()>

Asynchronously flushes outstanding memory map modifications in the range to disk(if the inner is a real file).

fn truncate(&mut self, max_sz: u64) -> Result<()>

Truncates the file to the max_size, which will lead to do re-mmap and sync_dir if the inner is a real file.

fn remove(self) -> Result<()>

Remove the underlying file

fn close_with_truncate(self, _max_sz: i64) -> Result<()>

Close and truncate the underlying file

fn slice_mut(&mut self, offset: usize, sz: usize) -> &mut [u8]

slice_mut returns mutable data starting from offset off of size sz.

fn bytes_mut(&mut self, offset: usize, sz: usize) -> Result<&mut [u8]>

bytes_mut returns mutable data starting from offset off of size sz.

fn zero_range(&mut self, start: usize, end: usize)

Fill 0 to the specific range

fn writer(&mut self, offset: usize) -> Result<MmapFileWriter<'_>>

Returns a MmapFileWriter base on the given offset, which helps read or write data from mmap like a normal File.

fn range_writer(
    &mut self,
    offset: usize,
    len: usize
) -> Result<MmapFileWriter<'_>>

Returns a MmapFileWriter base on the given offset and len, which helps read or write data from mmap like a normal File.

fn write(&mut self, src: &[u8], offset: usize) -> usize

Write bytes to the mmap from the offset.

fn write_all(&mut self, src: &[u8], offset: usize) -> Result<()>

Write the all of bytes in src to the mmap from the offset.

fn write_i8(&mut self, val: i8, offset: usize) -> Result<()>

Writes a signed 8 bit integer to mmap from the offset.

fn write_i16(&mut self, val: i16, offset: usize) -> Result<()>

Writes a signed 16 bit integer to mmap from the offset in the big-endian byte order.

fn write_i16_le(&mut self, val: i16, offset: usize) -> Result<()>

Writes a signed 16 bit integer to mmap from the offset in the little-endian byte order.

fn write_isize(&mut self, val: isize, offset: usize) -> Result<()>

Writes a signed integer to mmap from the offset in the big-endian byte order.

fn write_isize_le(&mut self, val: isize, offset: usize) -> Result<()>

Writes a signed integer to mmap from the offset in the little-endian byte order.

fn write_i32(&mut self, val: i32, offset: usize) -> Result<()>

Writes a signed 32 bit integer to mmap from the offset in the big-endian byte order.

fn write_i32_le(&mut self, val: i32, offset: usize) -> Result<()>

Writes a signed 32 bit integer to mmap from the offset in the little-endian byte order.

fn write_i64(&mut self, val: i64, offset: usize) -> Result<()>

Writes a signed 64 bit integer to mmap from the offset in the big-endian byte order.

fn write_i64_le(&mut self, val: i64, offset: usize) -> Result<()>

Writes a signed 64 bit integer to mmap from the offset in the little-endian byte order.

fn write_i128(&mut self, val: i128, offset: usize) -> Result<()>

Writes a signed 128 bit integer to mmap from the offset in the big-endian byte order.

fn write_i128_le(&mut self, val: i128, offset: usize) -> Result<()>

Writes a signed 128 bit integer to mmap from the offset in the little-endian byte order.

fn write_u8(&mut self, val: u8, offset: usize) -> Result<()>

Writes an unsigned 8 bit integer to mmap from the offset.

fn write_u16(&mut self, val: u16, offset: usize) -> Result<()>

Writes an unsigned 16 bit integer to mmap from the offset in the big-endian byte order.

fn write_u16_le(&mut self, val: u16, offset: usize) -> Result<()>

Writes an unsigned 16 bit integer to mmap from the offset in the little-endian byte order.

fn write_usize(&mut self, val: usize, offset: usize) -> Result<()>

Writes an unsigned integer to mmap from the offset in the big-endian byte order.

fn write_usize_le(&mut self, val: usize, offset: usize) -> Result<()>

Writes an unsigned integer to mmap from the offset in the little-endian byte order.

fn write_u32(&mut self, val: u32, offset: usize) -> Result<()>

Writes an unsigned 32 bit integer to mmap from the offset in the big-endian byte order.

fn write_u32_le(&mut self, val: u32, offset: usize) -> Result<()>

Writes an unsigned 32 bit integer to mmap from the offset in the little-endian byte order.

fn write_u64(&mut self, val: u64, offset: usize) -> Result<()>

Writes an unsigned 64 bit integer to mmap from the offset in the big-endian byte order.

fn write_u64_le(&mut self, val: u64, offset: usize) -> Result<()>

Writes an unsigned 64 bit integer to mmap from the offset in the little-endian byte order.

fn write_u128(&mut self, val: u128, offset: usize) -> Result<()>

Writes an unsigned 128 bit integer to mmap from the offset in the big-endian byte order.

fn write_u128_le(&mut self, val: u128, offset: usize) -> Result<()>

Writes an unsigned 128 bit integer to mmap from the offset in the little-endian byte order.

fn write_f32(&mut self, val: f32, offset: usize) -> Result<()>

Writes an IEEE754 single-precision (4 bytes) floating point number to mmap from the offset in big-endian byte order.

fn write_f32_le(&mut self, val: f32, offset: usize) -> Result<()>

Writes an IEEE754 single-precision (4 bytes) floating point number to mmap from the offset in little-endian byte order.

fn write_f64(&mut self, val: f64, offset: usize) -> Result<()>

Writes an IEEE754 single-precision (8 bytes) floating point number to mmap from the offset in big-endian byte order.

fn write_f64_le(&mut self, val: f64, offset: usize) -> Result<()>

Writes an IEEE754 single-precision (8 bytes) floating point number to mmap from the offset in little-endian byte order.

impl PartialEq<MemoryMmapFileMut> for MemoryMmapFileMut

fn eq(&self, other: &MemoryMmapFileMut) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Eq for MemoryMmapFileMut

impl StructuralEq for MemoryMmapFileMut

impl StructuralPartialEq for MemoryMmapFileMut