Struct MergedTree

pub struct MergedTree { /* private fields */ }

Presents a view of a merged set of trees.

Implementations

impl MergedTree

pub fn resolved(tree: Tree) -> Self

Creates a new MergedTree representing a single tree without conflicts.

pub fn new(trees: Merge<Tree>) -> Self

Creates a new MergedTree representing a merge of a set of trees. The individual trees must not have any conflicts.

pub fn from_legacy_tree(tree: Tree) -> BackendResult<Self>

Takes a tree in the legacy format (with path-level conflicts in the tree) and returns a MergedTree with any conflicts converted to tree-level conflicts.

pub fn as_merge(&self) -> &Merge<Tree>

Returns the underlying Merge<Tree>.

pub fn take(self) -> Merge<Tree>

Extracts the underlying Merge<Tree>.

pub fn dir(&self) -> &RepoPath

This tree’s directory

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

The Store associated with this tree.

pub fn names<'a>( &'a self, ) -> Box<dyn Iterator<Item = &'a RepoPathComponent> + 'a>

Base names of entries in this directory.

pub fn value(&self, basename: &RepoPathComponent) -> MergedTreeVal<'_>

The value at the given basename. The value can be Resolved even if self is a Merge, which happens if the value at the path can be trivially merged. Does not recurse, so if basename refers to a Tree, then a TreeValue::Tree will be returned.

pub fn resolve(&self) -> BackendResult<MergedTree>

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 has_conflict(&self) -> bool

Whether this tree has conflicts.

pub fn sub_tree( &self, name: &RepoPathComponent, ) -> BackendResult<Option<MergedTree>>

Gets the MergeTree in a subdirectory of the current tree. If the path doesn’t correspond to a tree in any of the inputs to the merge, then that entry will be replace by an empty tree in the result.

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 fn id(&self) -> MergedTreeId

The tree’s id

pub fn sub_tree_recursive( &self, path: &RepoPath, ) -> BackendResult<Option<MergedTree>>

Look up the tree at the given path.

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: &MergedTree, matcher: &'matcher dyn Matcher, ) -> TreeDiffStream<'matcher>

Stream of the differences between this tree and another tree.

The files in a removed tree will be returned before a file that replaces it.

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

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

pub fn merge( &self, base: &MergedTree, other: &MergedTree, ) -> BackendResult<MergedTree>

Merges this tree with other, using base as base. Any conflicts will be resolved recursively if possible.

pub fn merge_no_resolve( &self, base: &MergedTree, other: &MergedTree, ) -> MergedTree

Merges this tree with other, using base as base, 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.

impl PartialEq for MergedTree

fn eq(&self, other: &MergedTree) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for MergedTree

impl StructuralPartialEq for MergedTree