Struct Merge 

pub struct Merge<T> { /* private fields */ }

A generic representation of merged values.

There is exactly one more adds() than removes(). When interpreted as a series of diffs, the merge’s (i+1)-st add is matched with the i-th remove. The zeroth add is considered a diff from the non-existent state.

Implementations

impl<T> Merge<T>

pub fn from_vec(values: impl Into<SmallVec<[T; 1]>>) -> Self

Creates a Merge from the given values, in which positive and negative terms alternate.

pub fn from_removes_adds( removes: impl IntoIterator<Item = T>, adds: impl IntoIterator<Item = T>, ) -> Self

Creates a new merge object from the given removes and adds.

pub const fn resolved(value: T) -> Self

Creates a Merge with a single resolved value.

pub fn from_legacy_form( removes: impl IntoIterator<Item = T>, adds: impl IntoIterator<Item = T>, ) -> Merge<Option<T>>

Create a Merge from a removes and adds, padding with None to make sure that there is exactly one more adds than removes.

pub fn removes(&self) -> impl ExactSizeIterator<Item = &T>

The removed values, also called negative terms.

pub fn adds(&self) -> impl ExactSizeIterator<Item = &T>

The added values, also called positive terms.

pub fn first(&self) -> &T

Returns the zeroth added value, which is guaranteed to exist.

pub fn get_remove(&self, index: usize) -> Option<&T>

Returns the index-th removed value, which is considered belonging to the index-th diff pair.

pub fn get_add(&self, index: usize) -> Option<&T>

Returns the index-th added value, which is considered belonging to the index-1-th diff pair. The zeroth add is a diff from the non-existent state.

pub fn swap_remove(&mut self, remove_index: usize, add_index: usize) -> (T, T)

Removes the specified “removed”/“added” values. The removed slots are replaced by the last “removed”/“added” values.

pub fn num_sides(&self) -> usize

The number of positive terms in the conflict.

pub fn is_resolved(&self) -> bool

Whether this merge is resolved. Does not resolve trivial merges.

pub fn as_resolved(&self) -> Option<&T>

Returns the resolved value, if this merge is resolved. Does not resolve trivial merges.

pub fn into_resolved(self) -> Result<T, Self>

Returns the resolved value, if this merge is resolved. Otherwise returns the merge itself as an Err. Does not resolve trivial merges.

pub fn simplify(&self) -> Self

where T: PartialEq + Clone,

Simplify the merge by joining diffs like A->B and B->C into A->C. Also drops trivial diffs like A->A.

pub fn update_from_simplified(self, simplified: Self) -> Self

where T: PartialEq,

Updates the merge based on the given simplified merge.

pub fn resolve_trivial(&self, same_change: SameChange) -> Option<&T>

where T: Eq + Hash,

If this merge can be trivially resolved, returns the value it resolves to.

pub fn pad_to(&mut self, num_sides: usize, value: &T)

where T: Clone,

Pads this merge with to the specified number of sides with the specified value. No-op if the requested size is not larger than the current size.

pub fn as_slice(&self) -> &[T]

Returns a slice containing the terms. The items will alternate between positive and negative terms, starting with positive (since there’s one more of those).

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over references to the terms. The items will alternate between positive and negative terms, starting with positive (since there’s one more of those).

pub fn iter_mut(&mut self) -> IterMut<'_, T>

A version of Merge::iter() that iterates over mutable references.

pub fn map<'a, U>(&'a self, f: impl FnMut(&'a T) -> U) -> Merge<U>

Creates a new merge by applying f to each remove and add.

pub fn try_map<'a, U, E>( &'a self, f: impl FnMut(&'a T) -> Result<U, E>, ) -> Result<Merge<U>, E>

Creates a new merge by applying f to each remove and add, returning Err if freturnsErr` for any of them.

pub async fn try_map_async<'a, F, U, E>( &'a self, f: impl FnMut(&'a T) -> F, ) -> Result<Merge<U>, E>

where F: Future<Output = Result<U, E>>,

Creates a new merge by applying the async function f to each remove and add, running them concurrently, and returning Err if freturnsErr` for any of them.

impl<T> Merge<Option<T>>

pub fn absent() -> Self

Creates a resolved merge with a value of None.

pub fn normal(value: T) -> Self

Creates a resolved merge with a value of Some(value).

pub fn is_absent(&self) -> bool

Whether this represents a resolved value of None.

pub fn is_present(&self) -> bool

The opposite of is_absent().

pub fn as_normal(&self) -> Option<&T>

Returns the value if this is present and non-conflicting.

pub fn into_legacy_form(self) -> (Vec<T>, Vec<T>)

Creates lists of removes and adds from a Merge by dropping None values. Note that the conversion is lossy: the order of None values is not preserved when converting back to a Merge.

impl<T: Clone> Merge<Option<&T>>

pub fn cloned(&self) -> Merge<Option<T>>

Creates a new merge by cloning inner Option<&T>s.

impl<T> Merge<Merge<T>>

pub fn flatten(self) -> Merge<T>

Flattens a nested merge into a regular merge.

Let’s say we have a 3-way merge of 3-way merges like this:

4 5   7 8
 3     6
   1 2
    0

Flattening that results in this 9-way merge:

4 5 0 7 8
 3 2 1 6

impl<T> Merge<Option<T>>

where T: Borrow<TreeValue>,

pub fn is_tree(&self) -> bool

Whether this merge should be recursed into when doing directory walks.

pub fn is_file_like(&self) -> bool

Whether this merge is present and not a tree

pub fn to_file_merge(&self) -> Option<Merge<Option<FileId>>>

If this merge contains only files or absent entries, returns a merge of the FileIds. The executable bits and copy IDs will be ignored. Use Merge::with_new_file_ids() to produce a new merge with the original executable bits preserved.

pub fn to_executable_merge(&self) -> Option<Merge<Option<bool>>>

If this merge contains only files or absent entries, returns a merge of the files’ executable bits.

pub fn to_copy_id_merge(&self) -> Option<Merge<Option<CopyId>>>

If this merge contains only files or absent entries, returns a merge of the files’ copy IDs.

pub async fn to_tree_merge( &self, store: &Arc<Store>, dir: &RepoPath, ) -> BackendResult<Option<Merge<Tree>>>

If every non-None term of a MergedTreeValue is a TreeValue::Tree, this converts it to a Merge<Tree>, with empty trees instead of any None terms. Otherwise, returns None.

pub fn with_new_file_ids( &self, file_ids: &Merge<Option<FileId>>, ) -> Merge<Option<TreeValue>>

Creates a new merge with the file ids from the given merge. In other words, only the executable bits from self will be preserved.

The given file_ids should have the same shape as self. Only the FileId values may differ.

pub fn describe(&self) -> String

Give a summary description of the conflict’s “removes” and “adds”

impl Merge<Tree>

pub fn dir(&self) -> &RepoPath

The directory that is shared by all trees in the merge.

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

The value at the given basename. The value can be Resolved even if self is conflicted, 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 async fn sub_tree( &self, name: &RepoPathComponent, ) -> BackendResult<Option<Self>>

Gets the Merge<Tree> 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 replaced by an empty tree in the result.

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

Look up the tree at the given path.

Trait Implementations

impl<T: Clone> Clone for Merge<T>

fn clone(&self) -> Merge<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: ContentHash> ContentHash for Merge<T>

fn hash(&self, state: &mut impl DigestUpdate)

Update the hasher state with this object’s content

impl<T: Debug> Debug for Merge<T>

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

Formats the value using the given formatter.

impl<T: Hash> Hash for Merge<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> IntoIterator for Merge<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<[T; 1]>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for Merge<T>

fn eq(&self, other: &Merge<T>) -> 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<T> Serialize for Merge<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for Merge<T>

impl<T> StructuralPartialEq for Merge<T>