memmap2

https://docs.rs/memmap2/latest
Admin
A cross-platform Rust API for memory mapped buffers that provides immutable and mutable memory...
Tokens:333,570
Snippets:1,872
Trust Score:9.7
Update:3 days ago
Show doc for...
Tokens:
Raw
### Example of creating a file-backed memory map

Source: https://docs.rs/memmap2/latest/src/memmap2/lib.rs.html

This example demonstrates how to use MmapOptions to create a file-backed memory map from an existing file.

```rust
use memmap2::MmapOptions;
use std::io::Write;
use std::fs::File;

# fn main() -> std::io::Result<()> {
let file = File::open("README.md")?;
let mmap = unsafe { MmapOptions::new().map(&file)? };
assert_eq!(b"# memmap2", &mmap[0..9]);
# Ok(())
# }
```

--------------------------------

### Set offset with MmapOptions::offset and map a file

Source: https://docs.rs/memmap2/latest/src/memmap2/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates configuring a file-backed memory map to start at byte offset 30 from the beginning of the file. The example opens LICENSE-APACHE and asserts that the first 14 bytes match the string 'Apache License'.

```rust
use memmap2::MmapOptions;
use std::fs::File;

# fn main() -> std::io::Result<()> {
let mmap = unsafe {
    MmapOptions::new()
                .offset(30)
                .map(&File::open("LICENSE-APACHE")?)?
};
assert_eq!(&b"Apache License"[..],
           &mmap[..14]);
# Ok(())
# }

```

--------------------------------

### starts_with example: check if slice starts with a prefix

Source: https://docs.rs/memmap2/latest/memmap2/struct.Mmap.html?search=u32+-%3E+bool

Returns true if needle is a prefix of the slice or equal to the slice. Always returns true for an empty needle.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

--------------------------------

### is_sorted_by_key examples

Source: https://docs.rs/memmap2/latest/memmap2/struct.Mmap.html?search=u32+-%3E+bool

Shows how to use is_sorted_by_key with a key extraction function. The first example sorts by string length, the second by absolute value.

```rust
assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));
assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));
```

--------------------------------

### Basic SIMD Sum Example

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapMut.html

Demonstrates the usage of basic SIMD summation on a slice.

```rust
let numbers: Vec<f32> = (1..101).map(|x| x as _).collect();
assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);
```

--------------------------------

### Set offset with offset()

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapOptions.html?search=u32+-%3E+bool

Configures the memory map to start at a byte offset from the beginning of the file. The example opens a file and maps it with offset(30), then asserts the first 14 bytes match "Apache License".

```rust
use memmap2::MmapOptions;
use std::fs::File;

let mmap = unsafe {
    MmapOptions::new()
                .offset(30)
                .map(&File::open("LICENSE-APACHE")?)?
};
assert_eq!(&b"Apache License"[..],
           &mmap[..14]);
```

--------------------------------

### repeat method panic example

Source: https://docs.rs/memmap2/latest/memmap2/struct.Mmap.html

This example demonstrates a panic occurring at runtime due to capacity overflow.

```rust
// this will panic at runtime
b"0123456789abcdef".repeat(usize::MAX);
```

--------------------------------

### split_off usage examples

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapMut.html?search=

Examples of splitting a slice using one-sided ranges and handling out-of-bounds cases.

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut first_three = slice.split_off(..3).unwrap();

assert_eq!(slice, &['d']);
assert_eq!(first_three, &['a', 'b', 'c']);
```

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut tail = slice.split_off(2..).unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(tail, &['c', 'd']);
```

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];

assert_eq!(None, slice.split_off(5..));
assert_eq!(None, slice.split_off(..5));
assert_eq!(None, slice.split_off(..=4));
let expected: &[char] = &['a', 'b', 'c', 'd'];
assert_eq!(Some(expected), slice.split_off(..4));
```

--------------------------------

### Iterate over ranges

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapMut.html

Example demonstrating the iteration over ranges.

```rust
assert_eq!(iter.next(), Some(Range { start: 0, end: 0 }));
assert_eq!(iter.next(), Some(Range { start: 1, end: 3 }));
assert_eq!(iter.next(), Some(Range { start: 4, end: 4 }));
assert_eq!(iter.next(), Some(Range { start: 5, end: 6 }));
```

--------------------------------

### Mmap::make_mut Example

Source: https://docs.rs/memmap2/latest/memmap2/struct.Mmap.html

Shows how to transition a read-only memory map to a writable MmapMut instance.

```rust
use memmap2::Mmap;
use std::ops::DerefMut;
use std::io::Write;

let file = /* file opened with write permissions */
let mmap = unsafe { Mmap::map(&file)? };
// ... use the read-only memory map ...
let mut mut_mmap = mmap.make_mut()?;
mut_mmap.deref_mut().write_all(b"hello, world!")?;
```

--------------------------------

### repeat method example

Source: https://docs.rs/memmap2/latest/memmap2/struct.Mmap.html

Creates a vector by copying a slice n times.

```rust
assert_eq!([1, 2].repeat(3), vec![1, 2, 1, 2, 1, 2]);
```

--------------------------------

### Prefault pages with populate()

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapOptions.html?search=u32+-%3E+bool

Populates (prefaults) page tables for a mapping. The example opens a file and maps it with populate(), then asserts the first 9 bytes match "Copyright".

```rust
use memmap2::MmapOptions;
use std::fs::File;

let file = File::open("LICENSE-MIT")?;

let mmap = unsafe {
    MmapOptions::new().populate().map(&file)?
};

assert_eq!(&b"Copyright"[..], &mmap[..9]);
```

--------------------------------

### rsplit_mut example

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapMut.html

Demonstrates splitting a mutable slice into subslices starting from the end.

```rust
let mut v = [100, 400, 300, 200, 600, 500];

let mut count = 0;
for group in v.rsplit_mut(|num| *num % 3 == 0) {
    count += 1;
    group[0] = count;
}
assert_eq!(v, [3, 400, 300, 2, 600, 1]);
```

--------------------------------

### Example of as_rchunks_mut

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapMut.html

Demonstrates splitting a mutable slice into N-element arrays starting from the end, returning a remainder and chunks.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

let (remainder, chunks) = v.as_rchunks_mut();
remainder[0] = 9;
for chunk in chunks {
    *chunk = [count; 2];
    count += 1;
}
assert_eq!(v, &[9, 1, 1, 2, 2]);
```

--------------------------------

### Advice::PopulateRead

Source: https://docs.rs/memmap2/latest/src/memmap2/advice.rs.html

Linux only (since Linux 5.14). Populates (prefaults) page tables readable, faulting in all pages without actual memory access. Does not hide errors, can be applied to existing mappings. Cannot be applied to mappings without read permissions or special mappings. Process can be killed if system runs out of memory.

```APIDOC
## Advice::PopulateRead

### Description
Linux only (since Linux 5.14). Populates (prefaults) page tables readable, faulting in all pages without actual memory access. Does not hide errors, can be applied to existing mappings. Cannot be applied to mappings without read permissions or special mappings. Process can be killed if system runs out of memory.

### Availability
- Linux only

### Notes
- Corresponds to libc::MADV_POPULATE_READ
- Cannot be applied to mappings without read permissions or special mappings (e.g., VM_PFNMAP, VM_IO, secret memory regions)
- On failure, returns an error instead of generating SIGBUS
```

--------------------------------

### Example of as_chunks_mut

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapMut.html

Demonstrates splitting a mutable slice into N-element arrays starting from the beginning, returning chunks and a remainder.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

let (chunks, remainder) = v.as_chunks_mut();
remainder[0] = 9;
for chunk in chunks {
    *chunk = [count; 2];
    count += 1;
}
assert_eq!(v, &[1, 1, 2, 2, 9]);
```

--------------------------------

### Advice::PopulateRead

Source: https://docs.rs/memmap2/latest/src/memmap2/advice.rs.html?search=std%3A%3Avec

Populates (prefaults) page tables readable, faulting in all pages in the range without actual memory access. Useful for prefaulting file mappings. Linux only.

```APIDOC
## Advice::PopulateRead

### Description
Populates (prefaults) page tables readable, faulting in all pages in the range just as if manually reading from each page; however, avoids the actual memory access that would have been performed after handling the fault. In contrast to MAP_POPULATE, it does not hide errors, can be applied to (parts of) existing mappings, and will always populate page tables readable. One example use case is prefaulting a file mapping, reading all file content from disk; pages won't be dirtied and won't have to be written back to disk when evicting. Depending on the underlying mapping, it may map the shared zeropage, preallocate memory, or read the underlying file. If populating fails, a SIGBUS signal is not generated; instead, an error is returned. Cannot be applied to mappings without read permissions or special mappings (e.g., VM_PFNMAP, VM_IO, secret memory regions). The process can be killed at any moment when the system runs out of memory. Linux only (since Linux 5.14).

### Variant
Advice::PopulateRead

### Availability
- Linux only (since Linux 5.14)

### Notes
- Corresponds to libc::MADV_POPULATE_READ
```

--------------------------------

### Advice::PopulateWrite

Source: https://docs.rs/memmap2/latest/src/memmap2/advice.rs.html

Linux only (since Linux 5.14). Populates (prefaults) page tables writable, faulting in all pages without actual memory access. Does not hide errors, can be applied to existing mappings. Useful for preallocating memory and breaking CoW.

```APIDOC
## Advice::PopulateWrite

### Description
Linux only (since Linux 5.14). Populates (prefaults) page tables writable, faulting in all pages without actual memory access. Does not hide errors, can be applied to existing mappings. Useful for preallocating memory and breaking CoW.

### Availability
- Linux only

### Notes
- Corresponds to libc::MADV_POPULATE_WRITE
```

--------------------------------

### Advice::PopulateRead

Source: https://docs.rs/memmap2/latest/memmap2/enum.Advice.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Advice variant corresponding to MADV_POPULATE_READ, which prefaults page tables readable on Linux.

```APIDOC
## Advice::PopulateRead

### Description
Populates (prefaults) page tables readable, faulting in all pages as if manually reading from each page, but avoiding the actual memory access. Useful for prefaulting file mappings without dirtying pages.

### Variant
PopulateRead = 22

### Platform
Linux only (since Linux 5.14)

### Behavior
- Does not hide errors, unlike MAP_POPULATE.
- Can be applied to existing mappings.
- Always populates page tables readable.
- On failure, returns an error instead of generating SIGBUS.
- Cannot be applied to mappings without read permissions or special mappings (e.g., VM_PFNMAP, VM_IO, secret memory regions).
- Process may be killed if the system runs out of memory.

### Notes
- Corresponds to MADV_POPULATE_READ.
```

--------------------------------

### Sort slice example

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapMut.html

Basic example of sorting a mutable slice of integers.

```rust
let mut v = [4, -5, 1, -3, 2];
```

--------------------------------

### Split off slice starting with third element

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapMut.html

Splits off a sub-slice starting from the third element.

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut tail = slice.split_off(2..).unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(tail, &['c', 'd']);
```

--------------------------------

### Advice::PopulateWrite

Source: https://docs.rs/memmap2/latest/memmap2/enum.Advice.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Advice variant corresponding to MADV_POPULATE_WRITE, which prefaults page tables writable on Linux.

```APIDOC
## Advice::PopulateWrite

### Description
Populates (prefaults) page tables writable, faulting in all pages as if manually writing to each page, but avoiding the actual memory access. Useful for preallocating memory and breaking CoW.

### Variant
PopulateWrite = 23

### Platform
Linux only (since Linux 5.14)

### Behavior
- Does not hide errors, unlike MAP_POPULATE.
- Can be applied to existing mappings.
- Always populates page tables writable.
- On failure, returns an error instead of generating SIGBUS.
- Cannot be applied to mappings without write permissions or special mappings (e.g., VM_PFNMAP, VM_IO, secret memory regions).
- Process may be killed if the system runs out of memory.

### Notes
- Corresponds to MADV_POPULATE_WRITE.
```

--------------------------------

### Split off mut starting with third element

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapMut.html

Splits off a mutable sub-slice starting from the third element.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut tail = slice.split_off_mut(2..).unwrap();

assert_eq!(slice, &mut ['a', 'b']);
assert_eq!(tail, &mut ['c', 'd']);
```

--------------------------------

### Advice::PopulateWrite

Source: https://docs.rs/memmap2/latest/memmap2/enum.Advice.html?search=u32+-%3E+bool

Represents the MADV_POPULATE_WRITE advice, which prefaults page tables writable on Linux.

```APIDOC
## Advice::PopulateWrite

### Description
Populates (prefaults) page tables writable, faulting in all pages in the range without actual memory access. Useful for preallocating memory and breaking CoW.

### Variant
`Advice::PopulateWrite`

### Value
`23`

### Platform
Linux only (since Linux 5.14)

### Restrictions
- Cannot be applied to mappings without write permissions
- Cannot be applied to special mappings (e.g., VM_PFNMAP, VM_IO, secret memory regions)

### Notes
- Errors are returned instead of SIGBUS.
- Process can be killed if system runs out of memory.
- Corresponds to `MADV_POPULATE_WRITE`.
```

--------------------------------

### Apply Memory Advice on Unix

Source: https://docs.rs/memmap2/latest/src/memmap2/lib.rs.html

Demonstrates using advise and advise_range on Unix systems for both mutable and read-only memory maps.

```rust
#[test]
    #[cfg(unix)]
    fn advise() {
        let expected_len = 128;
        let tempdir = tempfile::tempdir().unwrap();
        let path = tempdir.path().join("mmap_advise");

        let file = OpenOptions::new()
            .read(true)
            .write(true)
            .create(true)
            .truncate(true)
            .open(path)
            .unwrap();

        file.set_len(expected_len as u64).unwrap();

        // Test MmapMut::advise
        let mut mmap = unsafe { MmapMut::map_mut(&file).unwrap() };
        mmap.advise(Advice::Random)
            .expect("mmap advising should be supported on unix");

        let len = mmap.len();
        assert_eq!(expected_len, len);

        let zeros = vec![0; len];
        let incr: Vec<u8> = (0..len as u8).collect();

        // check that the mmap is empty
        assert_eq!(&zeros[..], &mmap[..]);

        mmap.advise_range(Advice::Sequential, 0, mmap.len())
            .expect("mmap advising should be supported on unix");

        // write values into the mmap
        (&mut mmap[..]).write_all(&incr[..]).unwrap();

        // read values back
        assert_eq!(&incr[..], &mmap[..]);

        // Set advice and Read from the read-only map
        let mmap = unsafe { Mmap::map(&file).unwrap() };

        mmap.advise(Advice::Random)
            .expect("mmap advising should be supported on unix");

        // read values back
        assert_eq!(&incr[..], &mmap[..]);
    }
```

--------------------------------

### Advice::PopulateWrite

Source: https://docs.rs/memmap2/latest/src/memmap2/advice.rs.html?search=std%3A%3Avec

Populates (prefaults) page tables writable, faulting in all pages in the range as if manually writing to each page. Useful for preallocating memory and breaking CoW. Linux only.

```APIDOC
## Advice::PopulateWrite

### Description
Populates (prefaults) page tables writable, faulting in all pages in the range just as if manually writing to each page; however, avoids the actual memory access that would have been performed after handling the fault. In contrast to MAP_POPULATE, it does not hide errors, can be applied to (parts of) existing mappings, and will always populate page tables writable. One example use case is preallocating memory, breaking any CoW (Copy on Write). Linux only (since Linux 5.14).

### Variant
Advice::PopulateWrite

### Availability
- Linux only (since Linux 5.14)

### Notes
- Corresponds to libc::MADV_POPULATE_WRITE
```

--------------------------------

### split_off_mut usage examples

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapMut.html?search=

Examples of splitting a mutable slice using one-sided ranges and handling out-of-bounds cases.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut first_three = slice.split_off_mut(..3).unwrap();

assert_eq!(slice, &mut ['d']);
assert_eq!(first_three, &mut ['a', 'b', 'c']);
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut tail = slice.split_off_mut(2..).unwrap();

assert_eq!(slice, &mut ['a', 'b']);
assert_eq!(tail, &mut ['c', 'd']);
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];

assert_eq!(None, slice.split_off_mut(5..));
assert_eq!(None, slice.split_off_mut(..5));
assert_eq!(None, slice.split_off_mut(..=4));
let expected: &mut [_] = &mut ['a', 'b', 'c', 'd'];
assert_eq!(Some(expected), slice.split_off_mut(..4));
```

--------------------------------

### Advice::PopulateRead

Source: https://docs.rs/memmap2/latest/memmap2/enum.Advice.html?search=u32+-%3E+bool

Represents the MADV_POPULATE_READ advice, which prefaults page tables readable on Linux.

```APIDOC
## Advice::PopulateRead

### Description
Populates (prefaults) page tables readable, faulting in all pages in the range without actual memory access. Useful for prefaulting file mappings without dirtying pages.

### Variant
`Advice::PopulateRead`

### Value
`22`

### Platform
Linux only (since Linux 5.14)

### Restrictions
- Cannot be applied to mappings without read permissions
- Cannot be applied to special mappings (e.g., VM_PFNMAP, VM_IO, secret memory regions)

### Notes
- Errors are returned instead of SIGBUS.
- Process can be killed if system runs out of memory.
- Corresponds to `MADV_POPULATE_READ`.
```

--------------------------------

### strip_prefix

Source: https://docs.rs/memmap2/latest/memmap2/struct.Mmap.html

Returns a subslice with the prefix removed if the slice starts with the given prefix. Returns None if the slice does not start with the prefix.

```APIDOC
## strip_prefix

### Description
Returns a subslice with the prefix removed. If the slice starts with `prefix`, returns the subslice after the prefix, wrapped in `Some`. If `prefix` is empty, returns the original slice. If `prefix` is equal to the original slice, returns an empty slice. If the slice does not start with `prefix`, returns `None`.

### Method
strip_prefix

### Signature
pub fn strip_prefix<P>(&self, prefix: &P) -> Option<&[T]>
where P: SlicePattern<Item = T> + ?Sized, T: PartialEq,

### Parameters
- **prefix** (&P) - The prefix to strip. Must implement SlicePattern with Item = T.

### Return Value
- Option<&[T]> - The subslice after the prefix, or None if the slice does not start with the prefix.

### Examples
```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```
```

--------------------------------

### Simple Mmap usage example

Source: https://docs.rs/memmap2/latest/memmap2/index.html?search=std%3A%3Avec

Shows how to use Mmap to map a file and compare its contents with a vector read from the file. Requires a file named LICENSE-APACHE and uses unsafe code for the mapping.

```rust
use std::fs::File;
use std::io::Read;

use memmap2::Mmap;

let mut file = File::open("LICENSE-APACHE")?;

let mut contents = Vec::new();
file.read_to_end(&mut contents)?;

let mmap = unsafe { Mmap::map(&file)?  };

assert_eq!(&contents[..], &mmap[..]);
```

--------------------------------

### sort_by_key example

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapMut.html?search=std%3A%3Avec

Sorts a mutable slice in ascending order using a key extraction function. The example sorts by absolute value.

```rust
let mut v = [4i32, -5, 1, -3, 2];
v.sort_by_key(|k| k.abs());
assert_eq!(v, [1, 2, -3, 4, -5]);
```

--------------------------------

### Open file for writing

Source: https://docs.rs/memmap2/latest/src/memmap2/lib.rs.html?search=

Opens a file with read, write, and create permissions.

```rust
#[test]
    fn file_write() {
        let tempdir = tempfile::tempdir().unwrap();
        let path = tempdir.path().join("mmap");

        let mut file = OpenOptions::new()
            .read(true)
            .write(true)
            .create(true)
            .truncate(true)
            .open(path)
            .unwrap();
```

--------------------------------

### partition_point usage examples

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapMut.html?search=

Examples demonstrating how to use partition_point to find the index where a predicate changes from true to false, handle empty slices, and maintain sorted order during insertion.

```rust
assert_eq!(i, 4);
assert!(v[..i].iter().all(|&x| x < 5));
assert!(v[i..].iter().all(|&x| !(x < 5)));
```

```rust
let a = [2, 4, 8];
assert_eq!(a.partition_point(|x| x < &100), a.len());
let a: [i32; 0] = [];
assert_eq!(a.partition_point(|x| x < &100), 0);
```

```rust
let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x <= num);
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
```

--------------------------------

### Advice::PopulateWrite

Source: https://docs.rs/memmap2/latest/src/memmap2/advice.rs.html

Advice flag for MADV_POPULATE_WRITE on Linux. Preallocates memory or reads the underlying file, returning an error instead of generating a SIGBUS on failure. Cannot be applied to mappings without write permissions or special mappings.

```APIDOC
## Advice::PopulateWrite

### Description
Advice flag for MADV_POPULATE_WRITE on Linux. Preallocates memory or reads the underlying file, returning an error instead of generating a SIGBUS on failure. Cannot be applied to mappings without write permissions or special mappings.

### Platform
Linux

### Usage
Pass to Mmap::advise or MmapMut::advise.

### Notes
- If MADV_POPULATE_WRITE succeeds, all page tables have been populated writable once.
- If it fails, some page tables might have been populated.
- Cannot be applied to mappings without write permissions, special mappings (VM_PFNMAP, VM_IO), or secret memory regions.
- The process can be killed at any moment when the system runs out of memory.
```

--------------------------------

### split with predicate example

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapMut.html?search=u32+-%3E+bool

Returns an iterator over subslices separated by elements matching the predicate. The matched element is not included. The example shows a basic split where the matched element is in the middle.

```rust
let slice = [10, 40, 33, 20];
let mut iter = slice.split(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10, 40]);
assert_eq!(iter.next().unwrap(), &[20]);
assert!(iter.next().is_none());
```

--------------------------------

### Flushing memory map modifications

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapRaw.html

Example demonstrating how to create a memory map, write to it, and flush the changes to disk.

```rust
use std::fs::OpenOptions;
use std::io::Write;
use std::path::PathBuf;
use std::slice;

use memmap2::MmapRaw;

let tempdir = tempfile::tempdir()?;
let path: PathBuf = /* path to file */
let file = OpenOptions::new().read(true).write(true).create(true).truncate(true).open(&path)?;
file.set_len(128)?;

let mut mmap = unsafe { MmapRaw::map_raw(&file)? };

let mut memory = unsafe { slice::from_raw_parts_mut(mmap.as_mut_ptr(), 128) };
memory.write_all(b"Hello, world!")?;
mmap.flush()?;
```

--------------------------------

### sort_by_key example

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapMut.html?search=u32+-%3E+bool

Sorts a mutable slice in ascending order using a key extraction function. The example sorts by absolute value, resulting in [1, 2, -3, 4, -5].

```rust
v.sort_by_key(|k| k.abs());
assert_eq!(v, [1, 2, -3, 4, -5]);
```

--------------------------------

### map_mut example: writable memory map

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapOptions.html?search=u32+-%3E+bool

Creates a writable memory map backed by a file using MmapOptions::map_mut. Requires the file to be open with read and write permissions. The example writes data into the map with copy_from_slice.

```rust
use std::fs::OpenOptions;
use std::path::PathBuf;

use memmap2::MmapOptions;
let path: PathBuf = /* path to file */
let file = OpenOptions::new().read(true).write(true).create(true).truncate(true).open(&path)?;
file.set_len(13)?;

let mut mmap = unsafe {
    MmapOptions::new().map_mut(&file)?
};

mmap.copy_from_slice(b"Hello, world!");
```

--------------------------------

### JIT compilation on x86

Source: https://docs.rs/memmap2/latest/src/memmap2/lib.rs.html?search=std%3A%3Avec

Demonstrates writing machine code to a memory-mapped region and executing it.

```rust
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
    fn jit_x86(mut mmap: MmapMut) {
        mmap[0] = 0xB8; // mov eax, 0xAB
        mmap[1] = 0xAB;
        mmap[2] = 0x00;
        mmap[3] = 0x00;
        mmap[4] = 0x00;
        mmap[5] = 0xC3; // ret

        let mmap = mmap.make_exec().expect("make_exec");

        let jitfn: extern "C" fn() -> u8 = unsafe { mem::transmute(mmap.as_ptr()) };
        assert_eq!(jitfn(), 0xab);
    }
```

```rust
#[test]
    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
    fn jit_x86_anon() {
        jit_x86(MmapMut::map_anon(4096).unwrap());
    }
```

```rust
#[test]
    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
    fn jit_x86_file() {
        let tempdir = tempfile::tempdir().unwrap();
        let mut options = OpenOptions::new();
        #[cfg(windows)]
        options.access_mode(GENERIC_ALL);

        let file = options
            .read(true)
            .write(true)
            .create(true)
            .truncate(true)
            .open(tempdir.path().join("jit_x86"))
            .expect("open");

        file.set_len(4096).expect("set_len");
        jit_x86(unsafe { MmapMut::map_mut(&file).expect("map_mut") });
    }
```

--------------------------------

### map_copy_read_only example: copy-on-write read-only memory map

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapOptions.html?search=u32+-%3E+bool

Creates a copy-on-write read-only memory map backed by a file using MmapOptions::map_copy_read_only. Requires the file to be open with read permissions. The example reads the file contents and compares them to the mapped memory.

```rust
use memmap2::MmapOptions;
use std::fs::File;
use std::io::Read;

let mut file = File::open("README.md")?;

let mut contents = Vec::new();
file.read_to_end(&mut contents)?;

let mmap = unsafe {
    MmapOptions::new().map_copy_read_only(&file)?
};

assert_eq!(&contents[..], &mmap[..]);
```

--------------------------------

### as_chunks example: split into arrays with remainder

Source: https://docs.rs/memmap2/latest/memmap2/struct.Mmap.html?search=u32+-%3E+bool

Splits a slice into N-element arrays from the beginning, returning a remainder slice with length less than N. Panics if N is zero. The example shows a slice of length 5 split into chunks of 2 with a remainder of 1.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (chunks, remainder) = slice.as_chunks();
assert_eq!(chunks, &[['l', 'o'], ['r', 'e']]);
assert_eq!(remainder, &['m']);
```

--------------------------------

### make_exec

Source: https://docs.rs/memmap2/latest/memmap2/struct.MmapMut.html

Transition the memory map to be readable and executable. If the memory map is file-backed, the file must have been opened with execute permissions.

```APIDOC
## make_exec

### Description
Transition the memory map to be readable and executable. If the memory map is file-backed, the file must have been opened with execute permissions. On systems with separate instructions and data caches (a category that includes many ARM chips), a platform-specific call may be needed to ensure that the changes are visible to the execution unit (e.g. when using this function to implement a JIT compiler). For more details, see this ARM write-up or the `man` page for `sys_icache_invalidate`.

### Signature
`pub fn make_exec(self) -> Result<Mmap>`

### Errors
Returns an error when the underlying system call fails, such as when the file has not been opened with execute permissions.
```

--------------------------------

### jit_x86_file test: JIT with file-backed mapping

Source: https://docs.rs/memmap2/latest/src/memmap2/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a temporary file, sets its length to 4096, maps it as mutable, and passes it to jit_x86. On Windows, sets GENERIC_ALL access mode. Requires x86 or x86_64 architecture.

```rust
#[test]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
fn jit_x86_file() {
    let tempdir = tempfile::tempdir().unwrap();
    let mut options = OpenOptions::new();
    #[cfg(windows)]
    options.access_mode(GENERIC_ALL);

    let file = options
        .read(true)
        .write(true)
        .create(true)
        .truncate(true)
        .open(tempdir.path().join("jit_x86"))
        .expect("open");

    file.set_len(4096).expect("set_len");
    jit_x86(unsafe { MmapMut::map_mut(&file).expect("map_mut") });
}
```

--------------------------------

### concat method example

Source: https://docs.rs/memmap2/latest/memmap2/struct.Mmap.html

Flattens a slice of T into a single value.

```rust
assert_eq!(["hello", "world"].concat(), "helloworld");
assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]);
```

--------------------------------

### impl<T> Any for T

Source: https://docs.rs/memmap2/latest/memmap2/enum.UncheckedAdvice.html?search=

Provides the type_id method to get the TypeId of a value.

```APIDOC
## impl<T> Any for T

### Description
Provides the `type_id` method to get the `TypeId` of a value.

### Method
`fn type_id(&self) -> TypeId`

### Parameters
- **self** (&T) - The value whose type ID is requested.

### Returns
- **TypeId** - The `TypeId` of the value's type.
```
Tokens:
Raw