Struct File

pub struct File<T> { /* private fields */ }

An implementation of Persist based on an atomically-updated file at a given path. An exclusive lock is taken using flock(2) to ensure that concurrent updates cannot happen, and writes are saved to a staging file before being moved over the old file, an operation that is atomic on all Unixes.

Implementations

impl<T: Serialize + DeserializeOwned> File<T>

pub fn new(path: &Path, value: T) -> Result<Self, Error>

Creates a new persistent file at path containing value.

pub fn read(path: &Path) -> Result<Self, Error>

Reads the value from a file at path, returning an error if it does not exist.

pub fn read_or_create( path: &Path, value: impl FnOnce() -> Result<T, Error>, ) -> Result<Self, Error>

Reads the value from a file at path, calling the value function to create it if it does not exist. If it does exist, value will not be called.

Trait Implementations

impl<T> Deref for File<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for File<T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T: Serialize + DeserializeOwned + Send> Persist for File<T>

async fn persist(&mut self) -> Result<(), Error>

Writes the value to disk.

The contents of the file need to be over-written completely, so a temporary file is created as a backup in case a crash occurs while writing to disk.

The temporary file is then renamed to the original filename. If serialization or writing to disk fails, the temporary file is deleted.

fn into_value(self) -> T

Takes the value out, releasing the lock on the persistent file.

type Error = Error

fn as_mut(&mut self) -> &mut T

Gets a mutable reference to the value. This is not expressed as a DerefMut bound because it is discouraged to use this function! Instead, use mutate.