Struct MergedTree 

pub struct MergedTree { /* private fields */ }

Presents a view of a merged set of trees at the root directory, as well as conflict labels.

Implementations

impl MergedTree

pub fn resolved(store: Arc<Store>, tree_id: TreeId) -> Self

Creates a MergedTree with the given resolved tree ID.

pub fn new( store: Arc<Store>, tree_ids: Merge<TreeId>, labels: ConflictLabels, ) -> Self

Creates a MergedTree with the given tree IDs.

pub fn store(&self) -> &Arc<Store>

The Store associated with this tree.

pub fn tree_ids(&self) -> &Merge<TreeId>

The underlying tree IDs for this MergedTree. If there are file changes between two trees, then the tree IDs will be different.

pub fn into_tree_ids(self) -> Merge<TreeId>

Extracts the underlying tree IDs for this MergedTree, discarding any conflict labels.

pub fn labels(&self) -> &ConflictLabels

Returns this merge’s conflict labels, if any.

pub fn tree_ids_and_labels(&self) -> (&Merge<TreeId>, &ConflictLabels)

Returns both the underlying tree IDs and any conflict labels. This can be used to check whether there are changes in files to be materialized in the working copy.

pub fn into_tree_ids_and_labels(self) -> (Merge<TreeId>, ConflictLabels)

Extracts the underlying tree IDs and conflict labels.

pub async fn trees(&self) -> BackendResult<Merge<Tree>>

Reads the merge of tree objects represented by this MergedTree.

pub fn labels_by_term<'a>(&'a self, label: &'a str) -> Merge<&'a str>

Returns a label for each term in a merge. Resolved merges use the provided label, while conflicted merges keep their original labels. Missing labels are indicated by empty strings.

pub async fn resolve(self) -> BackendResult<Self>

Tries to resolve any conflicts, resolving any conflicts that can be automatically resolved and leaving the rest unresolved.

pub fn conflicts( &self, ) -> impl Iterator<Item = (RepoPathBuf, BackendResult<MergedTreeValue>)> + use<>

An iterator over the conflicts in this tree, including subtrees. Recurses into subtrees and yields conflicts in those, but only if all sides are trees, so tree/file conflicts will be reported as a single conflict, not one for each path in the tree.

pub fn conflicts_matching<'matcher>( &self, matcher: &'matcher dyn Matcher, ) -> impl Iterator<Item = (RepoPathBuf, BackendResult<MergedTreeValue>)> + use<'matcher>

Like conflicts() but restricted by a matcher.

pub fn has_conflict(&self) -> bool

Whether this tree has conflicts.

pub fn path_value(&self, path: &RepoPath) -> BackendResult<MergedTreeValue>

The value at the given path. The value can be Resolved even if self is a Conflict, which happens if the value at the path can be trivially merged.

pub async fn path_value_async( &self, path: &RepoPath, ) -> BackendResult<MergedTreeValue>

Async version of path_value().

pub fn entries(&self) -> TreeEntriesIterator<'static>

Iterator over the entries matching the given matcher. Subtrees are visited recursively. Subtrees that differ between the current MergedTree’s terms are merged on the fly. Missing terms are treated as empty directories. Subtrees that conflict with non-trees are not visited. For example, if current tree is a merge of 3 trees, and the entry for ‘foo’ is a conflict between a change subtree and a symlink (i.e. the subdirectory was replaced by symlink in one side of the conflict), then the entry for foo itself will be emitted, but no entries from inside foo/ from either of the trees will be.

pub fn entries_matching<'matcher>( &self, matcher: &'matcher dyn Matcher, ) -> TreeEntriesIterator<'matcher>

Like entries() but restricted by a matcher.

pub fn diff_stream<'matcher>( &self, other: &Self, matcher: &'matcher dyn Matcher, ) -> TreeDiffStream<'matcher>

Stream of the differences between this tree and another tree.

pub fn diff_stream_with_trees<'matcher>( &self, other: &Self, matcher: &'matcher dyn Matcher, ) -> TreeDiffStream<'matcher>

Like diff_stream() but trees with diffs themselves are also included.

pub fn diff_stream_for_file_system<'matcher>( &self, other: &Self, matcher: &'matcher dyn Matcher, ) -> TreeDiffStream<'matcher>

Like diff_stream() but files in a removed tree will be returned before a file that replaces it.

pub fn diff_stream_with_copies<'a>( &self, other: &Self, matcher: &'a dyn Matcher, copy_records: &'a CopyRecords, ) -> BoxStream<'a, CopiesTreeDiffEntry>

Like diff_stream() but takes the given copy records into account.

pub async fn merge(merge: Merge<(Self, String)>) -> BackendResult<Self>

Merges the provided trees into a single MergedTree. Any conflicts will be resolved recursively if possible. The provided labels are used if a conflict arises. However, if one of the input trees is already conflicted, the corresponding label will be ignored, and its existing labels will be used instead.

pub fn merge_no_resolve(merge: Merge<(Self, String)>) -> Self

Merges the provided trees into a single MergedTree, without attempting to resolve file conflicts.

Trait Implementations

impl Clone for MergedTree

fn clone(&self) -> MergedTree

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MergedTree

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

Formats the value using the given formatter.