Struct PersistentFileMapped 

pub struct PersistentFileMapped<T>(/* private fields */);

A [FileMapped] region that does not wipe pre-existing file contents when doublets grows it.

See the module documentation for the upstream behaviour this works around.

Implementations

impl<T> PersistentFileMapped<T>

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

Opens (creating it if needed) the file at path and maps it.

pub fn new(file: File) -> Result<Self>

Maps an already-opened file.

pub fn inner(&self) -> &FileMapped<T>

Borrows the wrapped [FileMapped].

impl<T: FileMappedValue> PersistentFileMapped<T>

pub fn open_existing(file: File) -> Result<Self>

Maps file and adopts the capacity represented by its existing bytes.

Unlike Self::new, which starts with a logical capacity of zero, this constructor makes every complete T already present in the file immediately visible through [RawMem::allocated]. Any trailing bytes that do not form a complete T are left untouched and ignored.

#![deny(unsafe_code)]
use std::fs::File;

use link_cli::doublets::unit::LinkPart;
use link_cli::PersistentFileMapped;

let file = File::options().read(true).write(true).open("links.data")?;
let mapped = PersistentFileMapped::<LinkPart<usize>>::open_existing(file)?;

Trait Implementations

impl<T: Debug> Debug for PersistentFileMapped<T>

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

Formats the value using the given formatter.

impl<T> RawMem for PersistentFileMapped<T>

fn grow_filled( &mut self, cap: usize, value: Self::Item, ) -> MemResult<&mut [Self::Item]>

where Self::Item: Clone,

Fills only the genuinely uninitialised tail of the grown region, keeping the bytes that were already persisted in the file.

type Item = T

The element type stored in this memory.

fn allocated(&self) -> &[Self::Item]

Returns a shared slice of all currently initialized elements.

fn allocated_mut(&mut self) -> &mut [Self::Item]

Returns a mutable slice of all currently initialized elements.

unsafe fn grow( &mut self, addition: usize, fill: impl FnOnce(usize, (&mut [Self::Item], &mut [MaybeUninit<Self::Item>])), ) -> MemResult<&mut [Self::Item]>

Low-level growth: extends the memory by cap elements.

fn shrink(&mut self, cap: usize) -> MemResult<()>

Removes the last cap elements, dropping them.

fn size_hint(&self) -> Option<usize>

Returns an optional hint about the total capacity, if known.

unsafe fn grow_assumed( &mut self, cap: usize, ) -> Result<&mut [Self::Item], Error>

grow which assumes that the memory is already initialized

unsafe fn grow_zeroed(&mut self, cap: usize) -> Result<&mut [Self::Item], Error>

Safety

unsafe fn grow_zeroed_exact( &mut self, cap: usize, ) -> Result<&mut [Self::Item], Error>

Safety

fn grow_with( &mut self, addition: usize, f: impl FnMut() -> Self::Item, ) -> Result<&mut [Self::Item], Error>

Grows by addition elements, initializing each with the closure f.

unsafe fn grow_with_exact( &mut self, addition: usize, f: impl FnMut() -> Self::Item, ) -> Result<&mut [Self::Item], Error>

Safety

unsafe fn grow_filled_exact( &mut self, cap: usize, value: Self::Item, ) -> Result<&mut [Self::Item], Error>

where Self::Item: Clone,

Safety

fn grow_within<R>(&mut self, range: R) -> Result<&mut [Self::Item], Error>

where R: RangeBounds<usize>, Self::Item: Clone,

Grows by cloning a sub-range of the currently allocated data.

fn grow_from_slice( &mut self, src: &[Self::Item], ) -> Result<&mut [Self::Item], Error>

where Self::Item: Clone,

Grows by cloning all elements from src.