Enum jj_lib::merged_tree::MergedTree

pub enum MergedTree {
    Legacy(Tree),
    Merge(Merge<Tree>),
}

Presents a view of a merged set of trees.

Variants

Legacy(Tree)

A single tree, possibly with path-level conflicts.

Merge(Merge<Tree>)

A merge of multiple trees, or just a single tree. The individual trees have no path-level conflicts.

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 legacy(tree: Tree) -> Self

Creates a new MergedTree backed by a tree with path-level 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 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) -> MergedTreeValue<'_>

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) -> Result<Merge<Tree>, TreeMergeError>

Tries to resolve any conflicts, resolving any conflicts that can be automatically resolved and leaving the rest unresolved. The returned conflict will either be resolved or have the same number of sides as the input.

pub fn conflicts( &self ) -> impl Iterator<Item = (RepoPath, Merge<Option<TreeValue>>)>

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) -> 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) -> Merge<Option<TreeValue>>

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 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<'matcher>( &self, other: &MergedTree, matcher: &'matcher dyn Matcher ) -> TreeDiffIterator<'matcher>

Iterate over 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_summary( &self, other: &MergedTree, matcher: &dyn Matcher ) -> DiffSummary

Collects lists of modified, added, and removed files between this tree and another tree.

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

Merges this tree with other, using base as base.

Trait Implementations

impl Clone for MergedTree

fn clone(&self) -> MergedTree

Returns a copy 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

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 MergedTree

impl StructuralEq for MergedTree

impl StructuralPartialEq for MergedTree