Struct StdFs 

pub struct StdFs;

ReadStorage over the process filesystem (std::fs).

The reference adapter, and the one ChangeSet is tuned for: it implements Storage too, and reports Capabilities::LOCAL_FS.

The traits are async so that genuinely async backends (network, OPFS) fit; this adapter’s futures are immediately ready, so any executor — including the dependency-free crate::exec::block_on — drives them to completion in a single poll.

Trait Implementations

impl Clone for StdFs

fn clone(&self) -> StdFs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for StdFs

impl Debug for StdFs

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

Formats the value using the given formatter.

impl Default for StdFs

fn default() -> StdFs

Returns the “default value” for a type.

impl ReadStorage for StdFs

async fn read(&self, path: &Path) -> Result<Vec<u8>, Error>

Read the entire contents of a file as bytes. Mirrors std::fs::read.

async fn read_to_string(&self, path: &Path) -> Result<String, Error>

Read the entire contents of a file as a string. Mirrors std::fs::read_to_string.

async fn read_dir(&self, path: &Path) -> Result<Vec<DirEntry>, Error>

Return the entries in a directory (non-recursive). Mirrors std::fs::read_dir, but yields a Vec since async iterators are not yet stable.

async fn metadata(&self, path: &Path) -> Result<Metadata, Error>

Return metadata about the entry at path. Mirrors std::fs::metadata; follows symlinks.

async fn executable(&self, path: &Path) -> Result<Option<bool>, Error>

Whether the file at path can be run — or None where that is not a thing this backend has.

async fn read_link(&self, path: &Path) -> Result<Option<PathBuf>, Error>

What the symbolic link at path points at, read rather than followed — or None where this backend models no links at all. Mirrors std::fs::read_link, with the decline folded in.

fn try_exists(&self, path: &Path) -> impl Future<Output = Result<bool, Error>>

Returns Ok(true) if the path exists, Ok(false) if it does not, and Err(_) if the check itself failed. Mirrors std::fs::try_exists.

impl Storage for StdFs

async fn write(&self, path: &Path, contents: &[u8]) -> Result<(), Error>

Write a file, replacing it if it already exists. Mirrors std::fs::write.

async fn create_new(&self, path: &Path, contents: &[u8]) -> Result<(), Error>

Create a file that must not already exist, and write contents to it. Mirrors std::fs::File::create_new followed by a full write.

async fn create_dir_all(&self, path: &Path) -> Result<(), Error>

Create a directory and all missing parents. Mirrors std::fs::create_dir_all.

async fn remove_file(&self, path: &Path) -> Result<(), Error>

Remove a regular file. Mirrors std::fs::remove_file.

async fn remove_dir_all(&self, path: &Path) -> Result<(), Error>

Recursively remove a directory and its contents. Mirrors std::fs::remove_dir_all.

async fn rename(&self, from: &Path, to: &Path) -> Result<(), Error>

Rename or move a file or directory. Mirrors std::fs::rename — and the load-bearing half of the mirror is that an occupied destination file is replaced, as std::fs::rename replaces one on every platform this crate targets. The default write_atomic publishes by renaming a staged sibling over the target, so a backend whose rename refuses an occupied file cannot take that default and must override write_atomic with its own atomic replacement. A directory destination is another matter — std::fs::rename itself is platform-divergent there — and nothing in this crate renames onto one.

async fn set_executable( &self, path: &Path, executable: bool, ) -> Result<(), Error>

Make the file at path runnable, or not. One bit, not a mode: nothing else about the file changes.

async fn set_link(&self, path: &Path, target: &Path) -> Result<(), Error>

Place a symbolic link at path pointing at target, replacing whatever is there.

async fn copy_permissions(&self, from: &Path, to: &Path) -> Result<(), Error>

Give to the same access permissions from has. A from that does not exist is not an error — there is no prior state to carry over, so the call has nothing to do.

fn capabilities(&self) -> Capabilities

What durability guarantees this backend can make. Defaults to Capabilities::NONE — a backend promises a guarantee only by saying so, so an adapter that forgets to override this degrades to the most defensive path rather than to a false promise.

async fn sync(&self, path: &Path, need: Durability) -> Result<(), Error>

Flush path — and nothing else — to the strength need asks for.

fn replace( &self, path: &Path, contents: &[u8], ) -> impl Future<Output = Result<(), Error>>

Replace path’s contents with contents atomically — and only atomically: no observer ever sees a splice of old and new bytes, but nothing here outlives a power cut until the caller flushes it. The atomic half of write_atomic, split out so that a protocol landing many replacements can batch one drain instead of paying one per file — which is exactly what ChangeSet and OrderedBatch do, settling the whole set’s flush debt once before the state is certified.

fn write_atomic( &self, path: &Path, contents: &[u8], ) -> impl Future<Output = Result<(), Error>>

Replace path’s contents with contents atomically and durably: no observer — concurrent reader or post-crash survivor — ever sees a splice of old and new bytes, and once this returns the new contents outlive a power loss.