Struct vfs::path::VfsPath

pub struct VfsPath { /* private fields */ }

A virtual filesystem path, identifying a single file or directory in this virtual filesystem

Implementations

impl VfsPath

pub fn new<T: FileSystem>(filesystem: T) -> Self

Creates a root path for the given filesystem

let path = VfsPath::new(PhysicalFS::new("."));

pub fn as_str(&self) -> &str

Returns the string representation of this path

let path = VfsPath::new(PhysicalFS::new("."));

assert_eq!(path.as_str(), "");
assert_eq!(path.join("foo.txt")?.as_str(), "/foo.txt");

pub fn join(&self, path: impl AsRef<str>) -> VfsResult<Self>

Appends a path segment to this path, returning the result

let path = VfsPath::new(PhysicalFS::new("."));

assert_eq!(path.join("foo.txt")?.as_str(), "/foo.txt");
assert_eq!(path.join("foo/bar.txt")?.as_str(), "/foo/bar.txt");

let foo = path.join("foo")?;

assert_eq!(path.join("foo/bar.txt")?, foo.join("bar.txt")?);
assert_eq!(path, foo.join("..")?);

pub fn root(&self) -> VfsPath

Returns the root path of this filesystem

let path = VfsPath::new(MemoryFS::new());
let directory = path.join("foo/bar")?;

assert_eq!(directory.root(), path);

pub fn is_root(&self) -> bool

Returns true if this is the root path

let path = VfsPath::new(MemoryFS::new());
assert!(path.is_root());
let path = path.join("foo/bar")?;
assert!(! path.is_root());

pub fn create_dir(&self) -> VfsResult<()>

Creates the directory at this path

Note that the parent directory must exist, while the given path must not exist.

Returns VfsErrorKind::FileExists if a file already exists at the given path Returns VfsErrorKind::DirectoryExists if a directory already exists at the given path

let path = VfsPath::new(MemoryFS::new());
let directory = path.join("foo")?;

directory.create_dir()?;

assert!(directory.exists()?);
assert_eq!(directory.metadata()?.file_type, VfsFileType::Directory);

pub fn create_dir_all(&self) -> VfsResult<()>

Creates the directory at this path, also creating parent directories as necessary

let path = VfsPath::new(MemoryFS::new());
let directory = path.join("foo/bar")?;

directory.create_dir_all()?;

assert!(directory.exists()?);
assert_eq!(directory.metadata()?.file_type, VfsFileType::Directory);
let parent = path.join("foo")?;
assert!(parent.exists()?);
assert_eq!(parent.metadata()?.file_type, VfsFileType::Directory);

pub fn read_dir(&self) -> VfsResult<Box<dyn Iterator<Item = VfsPath> + Send>>

Iterates over all entries of this directory path

let path = VfsPath::new(MemoryFS::new());
path.join("foo")?.create_dir()?;
path.join("bar")?.create_dir()?;

let mut directories: Vec<_> = path.read_dir()?.collect();

directories.sort_by_key(|path| path.as_str().to_string());
assert_eq!(directories, vec![path.join("bar")?, path.join("foo")?]);

pub fn create_file(&self) -> VfsResult<Box<dyn SeekAndWrite + Send>>

Creates a file at this path for writing, overwriting any existing file

use vfs::{MemoryFS, VfsError, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let file = path.join("foo.txt")?;

write!(file.create_file()?, "Hello, world!")?;

let mut result = String::new();
file.open_file()?.read_to_string(&mut result)?;
assert_eq!(&result, "Hello, world!");

pub fn open_file(&self) -> VfsResult<Box<dyn SeekAndRead + Send>>

Opens the file at this path for reading

use vfs::{MemoryFS, VfsError, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let file = path.join("foo.txt")?;
write!(file.create_file()?, "Hello, world!")?;
let mut result = String::new();

file.open_file()?.read_to_string(&mut result)?;

assert_eq!(&result, "Hello, world!");

pub fn append_file(&self) -> VfsResult<Box<dyn SeekAndWrite + Send>>

Opens the file at this path for appending

use vfs::{MemoryFS, VfsError, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let file = path.join("foo.txt")?;
write!(file.create_file()?, "Hello, ")?;
write!(file.append_file()?, "world!")?;
let mut result = String::new();
file.open_file()?.read_to_string(&mut result)?;
assert_eq!(&result, "Hello, world!");

pub fn remove_file(&self) -> VfsResult<()>

Removes the file at this path

use vfs::{MemoryFS, VfsError, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let file = path.join("foo.txt")?;
write!(file.create_file()?, "Hello, ")?;
assert!(file.exists()?);

file.remove_file()?;

assert!(!file.exists()?);

pub fn remove_dir(&self) -> VfsResult<()>

Removes the directory at this path

The directory must be empty.

use vfs::{MemoryFS, VfsError, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let directory = path.join("foo")?;
directory.create_dir();
assert!(directory.exists()?);

directory.remove_dir()?;

assert!(!directory.exists()?);

pub fn remove_dir_all(&self) -> VfsResult<()>

Ensures that the directory at this path is removed, recursively deleting all contents if necessary

Returns successfully if directory does not exist

use vfs::{MemoryFS, VfsError, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let directory = path.join("foo")?;
directory.join("bar")?.create_dir_all();
assert!(directory.exists()?);

directory.remove_dir_all()?;

assert!(!directory.exists()?);

pub fn metadata(&self) -> VfsResult<VfsMetadata>

Returns the file metadata for the file at this path

use vfs::{MemoryFS, VfsError, VfsFileType, VfsMetadata, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let directory = path.join("foo")?;
directory.create_dir();

assert_eq!(directory.metadata()?.len, 0);
assert_eq!(directory.metadata()?.file_type, VfsFileType::Directory);

let file = path.join("bar.txt")?;
write!(file.create_file()?, "Hello, world!")?;

assert_eq!(file.metadata()?.len, 13);
assert_eq!(file.metadata()?.file_type, VfsFileType::File);

pub fn set_creation_time(&self, time: SystemTime) -> VfsResult<()>

Sets the files creation timestamp at this path

use std::time::SystemTime;
use vfs::{MemoryFS, VfsError, VfsFileType, VfsMetadata, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let file = path.join("foo.txt")?;
file.create_file();

let time = SystemTime::now();
file.set_creation_time(time);

assert_eq!(file.metadata()?.len, 0);
assert_eq!(file.metadata()?.created, Some(time));

pub fn set_modification_time(&self, time: SystemTime) -> VfsResult<()>

Sets the files modification timestamp at this path

use std::time::SystemTime;
use vfs::{MemoryFS, VfsError, VfsFileType, VfsMetadata, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let file = path.join("foo.txt")?;
file.create_file();

let time = SystemTime::now();
file.set_modification_time(time);

assert_eq!(file.metadata()?.len, 0);
assert_eq!(file.metadata()?.modified, Some(time));

pub fn set_access_time(&self, time: SystemTime) -> VfsResult<()>

Sets the files access timestamp at this path

use std::time::SystemTime;
use vfs::{MemoryFS, VfsError, VfsFileType, VfsMetadata, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let file = path.join("foo.txt")?;
file.create_file();

let time = SystemTime::now();
file.set_access_time(time);

assert_eq!(file.metadata()?.len, 0);
assert_eq!(file.metadata()?.accessed, Some(time));

pub fn is_file(&self) -> VfsResult<bool>

Returns true if the path exists and is pointing at a regular file, otherwise returns false.

Note that this call may fail if the file’s existence cannot be determined or the metadata can not be retrieved

use vfs::{MemoryFS, VfsError, VfsFileType, VfsMetadata, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let directory = path.join("foo")?;
directory.create_dir()?;
let file = path.join("foo.txt")?;
file.create_file()?;

assert!(!directory.is_file()?);
assert!(file.is_file()?);

pub fn is_dir(&self) -> VfsResult<bool>

Returns true if the path exists and is pointing at a directory, otherwise returns false.

Note that this call may fail if the directory’s existence cannot be determined or the metadata can not be retrieved

use vfs::{MemoryFS, VfsError, VfsFileType, VfsMetadata, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let directory = path.join("foo")?;
directory.create_dir()?;
let file = path.join("foo.txt")?;
file.create_file()?;

assert!(directory.is_dir()?);
assert!(!file.is_dir()?);

pub fn exists(&self) -> VfsResult<bool>

Returns true if a file or directory exists at this path, false otherwise

use vfs::{MemoryFS, VfsError, VfsFileType, VfsMetadata, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let directory = path.join("foo")?;

assert!(!directory.exists()?);

directory.create_dir();

assert!(directory.exists()?);

pub fn filename(&self) -> String

Returns the filename portion of this path

use vfs::{MemoryFS, VfsError, VfsFileType, VfsMetadata, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let file = path.join("foo/bar.txt")?;

assert_eq!(&file.filename(), "bar.txt");

pub fn extension(&self) -> Option<String>

Returns the extension portion of this path

use vfs::{MemoryFS, VfsError, VfsFileType, VfsMetadata, VfsPath};
let path = VfsPath::new(MemoryFS::new());

assert_eq!(path.join("foo/bar.txt")?.extension(), Some("txt".to_string()));
assert_eq!(path.join("foo/bar.txt.zip")?.extension(), Some("zip".to_string()));
assert_eq!(path.join("foo/bar")?.extension(), None);

pub fn parent(&self) -> Self

Returns the parent path of this portion of this path

Root will return itself.

use vfs::{MemoryFS, VfsError, VfsFileType, VfsMetadata, VfsPath};
let path = VfsPath::new(MemoryFS::new());

assert_eq!(path.parent(), path.root());
assert_eq!(path.join("foo/bar")?.parent(), path.join("foo")?);
assert_eq!(path.join("foo")?.parent(), path);

pub fn walk_dir(&self) -> VfsResult<WalkDirIterator>

Recursively iterates over all the directories and files at this path

Directories are visited before their children

Note that the iterator items can contain errors, usually when directories are removed during the iteration. The returned paths may also point to non-existant files if there is concurrent removal.

Also note that loops in the file system hierarchy may cause this iterator to never terminate.

let root = VfsPath::new(MemoryFS::new());
root.join("foo/bar")?.create_dir_all()?;
root.join("fizz/buzz")?.create_dir_all()?;
root.join("foo/bar/baz")?.create_file()?;

let mut directories = root.walk_dir()?.collect::<VfsResult<Vec<_>>>()?;

directories.sort_by_key(|path| path.as_str().to_string());
let expected = vec!["fizz", "fizz/buzz", "foo", "foo/bar", "foo/bar/baz"].iter().map(|path| root.join(path)).collect::<VfsResult<Vec<_>>>()?;
assert_eq!(directories, expected);

pub fn read_to_string(&self) -> VfsResult<String>

Reads a complete file to a string

Returns an error if the file does not exist or is not valid UTF-8

use vfs::{MemoryFS, VfsError, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let file = path.join("foo.txt")?;
write!(file.create_file()?, "Hello, world!")?;

let result = file.read_to_string()?;

assert_eq!(&result, "Hello, world!");

pub fn copy_file(&self, destination: &VfsPath) -> VfsResult<()>

Copies a file to a new destination

The destination must not exist, but its parent directory must

use vfs::{MemoryFS, VfsError, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let src = path.join("foo.txt")?;
write!(src.create_file()?, "Hello, world!")?;
let dest = path.join("bar.txt")?;

src.copy_file(&dest)?;

assert_eq!(dest.read_to_string()?, "Hello, world!");

pub fn move_file(&self, destination: &VfsPath) -> VfsResult<()>

Moves or renames a file to a new destination

The destination must not exist, but its parent directory must

use vfs::{MemoryFS, VfsError, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let src = path.join("foo.txt")?;
write!(src.create_file()?, "Hello, world!")?;
let dest = path.join("bar.txt")?;

src.move_file(&dest)?;

assert_eq!(dest.read_to_string()?, "Hello, world!");
assert!(!src.exists()?);

pub fn copy_dir(&self, destination: &VfsPath) -> VfsResult<u64>

Copies a directory to a new destination, recursively

The destination must not exist, but the parent directory must

Returns the number of files copied

use vfs::{MemoryFS, VfsError, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let src = path.join("foo")?;
src.join("dir")?.create_dir_all()?;
let dest = path.join("bar.txt")?;

src.copy_dir(&dest)?;

assert!(dest.join("dir")?.exists()?);

pub fn move_dir(&self, destination: &VfsPath) -> VfsResult<()>

Moves a directory to a new destination, including subdirectories and files

The destination must not exist, but its parent directory must

use vfs::{MemoryFS, VfsError, VfsPath};
let path = VfsPath::new(MemoryFS::new());
let src = path.join("foo")?;
src.join("dir")?.create_dir_all()?;
let dest = path.join("bar.txt")?;

src.move_dir(&dest)?;

assert!(dest.join("dir")?.exists()?);
assert!(!src.join("dir")?.exists()?);

Trait Implementations

impl Clone for VfsPath

fn clone(&self) -> VfsPath

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VfsPath

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

Formats the value using the given formatter.

impl<T: FileSystem> From<T> for VfsPath

fn from(filesystem: T) -> Self

Converts to this type from the input type.

impl PartialEq for VfsPath

fn eq(&self, other: &Self) -> 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 Eq for VfsPath