Struct virtual_fs::overlay_fs::OverlayFileSystem

pub struct OverlayFileSystem<P, S> {
    primary: Arc<P>,
    secondaries: S,
}

A primary filesystem and chain of secondary filesystems that are overlayed on top of each other.

Precedence

The OverlayFileSystem will execute operations based on precedence.

Most importantly, this means earlier filesystems can shadow files and directories that have a lower precedence.

Examples

Something useful to know is that the FileSystems trait is implemented for both arrays and tuples.

For example, if you want to create a crate::FileSystem which will create files in-memory while still being able to read from the host, you might do something like this:

use virtual_fs::{
    mem_fs::FileSystem as MemFS,
    host_fs::FileSystem as HostFS,
    OverlayFileSystem,
};

let runtime = tokio::runtime::Builder::new_current_thread()
    .enable_all()
    .build()
    .unwrap();
let _guard = runtime.enter();

let fs = OverlayFileSystem::new(MemFS::default(), [HostFS::new(tokio::runtime::Handle::current(), "/").unwrap()]);

// This also has the benefit of storing the two values in-line with no extra
// overhead or indirection.
assert_eq!(
    std::mem::size_of_val(&fs),
    std::mem::size_of::<(MemFS, HostFS)>(),
);

A more complex example is

Fields

primary: Arc<P>

secondaries: S

Implementations

impl<P, S> OverlayFileSystem<P, S>

where P: FileSystem + Send + Sync + 'static, S: for<'a> FileSystems<'a> + Send + Sync + 'static,

pub fn new(primary: P, secondaries: S) -> Self

Create a new FileSystem using a primary crate::FileSystem and a chain of secondary FileSystems.

pub fn primary(&self) -> &P

Get a reference to the primary filesystem.

pub fn secondaries(&self) -> &S

Get a reference to the secondary filesystems.

pub fn secondaries_mut(&mut self) -> &mut S

Get a mutable reference to the secondary filesystems.

fn permission_error_or_not_found(&self, path: &Path) -> Result<(), FsError>

Trait Implementations

impl<P: Clone, S: Clone> Clone for OverlayFileSystem<P, S>

fn clone(&self) -> OverlayFileSystem<P, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P, S> Debug for OverlayFileSystem<P, S>

where P: FileSystem, S: for<'a> FileSystems<'a>,

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

Formats the value using the given formatter.

impl<P, S> FileOpener for OverlayFileSystem<P, S>

where P: FileSystem + Send + 'static, S: for<'a> FileSystems<'a> + Send + Sync + 'static, for<'a> <<S as FileSystems<'a>>::Iter as IntoIterator>::IntoIter: Send,

fn open( &self, path: &Path, conf: &OpenOptionsConfig, ) -> Result<Box<dyn VirtualFile + Send + Sync + 'static>, FsError>

impl<P, S> FileSystem for OverlayFileSystem<P, S>

where P: FileSystem + Send + 'static, S: for<'a> FileSystems<'a> + Send + Sync + 'static, for<'a> <<S as FileSystems<'a>>::Iter as IntoIterator>::IntoIter: Send,

fn readlink(&self, path: &Path) -> Result<PathBuf>

fn read_dir(&self, path: &Path) -> Result<ReadDir, FsError>

fn create_dir(&self, path: &Path) -> Result<(), FsError>

fn remove_dir(&self, path: &Path) -> Result<(), FsError>

fn rename<'a>( &'a self, from: &'a Path, to: &'a Path, ) -> BoxFuture<'a, Result<(), FsError>>

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

fn symlink_metadata(&self, path: &Path) -> Result<Metadata>

This method gets metadata without following symlinks in the path. Currently identical to metadata because symlinks aren’t implemented yet.

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

fn new_open_options(&self) -> OpenOptions<'_>

fn mount( &self, _name: String, _path: &Path, _fs: Box<dyn FileSystem + Send + Sync>, ) -> Result<(), FsError>

impl<P: PartialEq, S: PartialEq> PartialEq for OverlayFileSystem<P, S>

fn eq(&self, other: &OverlayFileSystem<P, S>) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P: Eq, S: Eq> Eq for OverlayFileSystem<P, S>

impl<P, S> StructuralPartialEq for OverlayFileSystem<P, S>