Struct JointDirectory

pub struct JointDirectory { /* private fields */ }

Unified view over multiple concurrent versions of a directory.

Implementations

impl JointDirectory

pub fn new<I>(local_branch: Option<Branch>, versions: I) -> Self

where I: IntoIterator<Item = Directory>,

Creates a new JointDirectory over the specified directory versions.

Note: if local_branch is None then the created joint directory is read-only.

pub fn is_empty(&self) -> bool

pub fn entries(&self) -> impl Iterator<Item = JointEntryRef<'_>>

Returns iterator over the entries of this directory. Multiple concurrent versions of the same file are returned as separate JointEntryRef::File entries. Multiple concurrent versions of the same directory are returned as a single JointEntryRef::Directory entry.

pub fn lookup<'a>( &'a self, name: &'a str, ) -> impl Iterator<Item = JointEntryRef<'a>> + 'a

Returns all versions of an entry with the given name. Concurrent file versions are returned separately but concurrent directory versions are merged into a single JointDirectory.

pub fn lookup_unique<'a>(&'a self, name: &'a str) -> Result<JointEntryRef<'a>>

Looks up single entry with the specified name if it is unique.

• If there is only one version of a entry with the specified name, it is returned.
• If there are multiple versions and all of them are files, an AmbiguousEntry error is returned. To lookup a single version, include a disambiguator in the name.
• If there are multiple versiond and all of them are directories, they are merged into a single JointEntryRef::Directory and returned.
• Finally, if there are both files and directories, only the directories are retured (merged into a JointEntryRef::Directory) and the files are discarded. This is so it’s possible to unambiguously lookup a directory even in the presence of conflicting files.

pub fn lookup_version( &self, name: &str, branch_id: &PublicKey, ) -> Result<FileRef<'_>>

Looks up a specific version of a file.

pub fn len(&self) -> u64

Length of the directory in bytes. If there are multiple versions, returns the sum of their lengths.

pub fn has_local_version(&self) -> bool

pub async fn cd(&self, path: impl AsRef<Utf8Path>) -> Result<Self>

Descends into an arbitrarily nested subdirectory of this directory at the specified path. Note: non-normalized paths (i.e. containing “..”) or Windows-style drive prefixes (e.g. “C:”) are not supported.

pub async fn remove_entry(&mut self, name: &str) -> Result<()>

Removes the specified entry from this directory. If the entry is a subdirectory, it has to be empty. Use Self::remove_entry_recursively to remove non-empty subdirectories.

pub async fn remove_entry_recursively(&mut self, name: &str) -> Result<()>

Removes the specified entry from this directory, including all its content if it is a subdirectory.

pub fn merge<'life_self, 'async_recursion>( &'life_self mut self, ) -> Pin<Box<dyn Future<Output = Result<Directory>> + Send + 'async_recursion>>

where 'life_self: 'async_recursion,

Merge all versions of this JointDirectory into a single Directory.

In the presence of conflicts (multiple concurrent versions of the same file) this function still proceeds as far as it can, but the conflicting files remain unmerged. It signals this by returning Error::AmbiguousEntry.

Trait Implementations

impl Clone for JointDirectory

fn clone(&self) -> JointDirectory

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for JointDirectory

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

Formats the value using the given formatter.