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]>>) -> Merge<T>

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>, ) -> Merge<T>

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

pub fn from_diffs( first_side: T, diffs: impl IntoIterator<Item = Diff<T>>, ) -> Merge<T>

Creates a Merge from a first side and a series of diffs to apply to that side.

pub const fn resolved(value: T) -> Merge<T>

Creates a Merge with a single resolved value.

pub fn repeated(value: T, num_sides: usize) -> Merge<T>

where T: Clone,

Creates a Merge by repeating a single 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

The removed values, also called negative terms.

pub fn adds(&self) -> impl ExactSizeIterator

The added values, also called positive terms.

pub fn into_removes_adds( self, ) -> (impl ExactSizeIterator, impl ExactSizeIterator)

Return the removed values and added values and take the ownership.

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, Merge<T>>

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) -> Merge<T>

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 simplify_by<'a, U>(&'a self, f: impl FnMut(&'a T) -> U) -> Merge<T>

where T: Clone, U: PartialEq,

Simplify the merge, using a function to choose which values to compare.

pub fn update_from_simplified(self, simplified: Merge<T>) -> Merge<T>

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 into_map<U>(self, f: impl FnMut(T) -> U) -> Merge<U>

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

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 f returns Err 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 f returns Err for any of them.

pub fn as_ref(&self) -> Merge<&T>

Converts a &Merge<T> into a Merge<&T>.

pub fn zip<U>(self, other: Merge<U>) -> Merge<(T, U)>

Zip two merges which have the same number of terms. Panics if the merges don’t have the same number of terms.

impl<T, U> Merge<(T, U)>

pub fn unzip(self) -> (Merge<T>, Merge<U>)

Unzips a merge of pairs into a pair of merges.

impl<T> Merge<&T>

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

where T: Clone,

Convert a Merge<&T> into a Merge<T> by cloning each term.

impl<T> Merge<Option<T>>

pub fn absent() -> Merge<Option<T>>

Creates a resolved merge with a value of None.

pub fn normal(value: T) -> Merge<Option<T>>

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> Merge<Option<&T>>

where T: Clone,

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

Trait Implementations

impl<T> Clone for Merge<T>

where T: Clone,

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 for Merge<T>

where T: ContentHash,

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

Update the hasher state with this object’s content

impl<T> Debug for Merge<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Eq for Merge<T>

where T: Eq,

impl<T> Hash for Merge<T>

where T: Hash,

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

where __H: Hasher,

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) -> <Merge<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Merge<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Merge<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Merge<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut Merge<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T> MergedTreeValueExt for Merge<Option<T>>

where T: Borrow<TreeValue>,

fn is_tree(&self) -> bool

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

fn is_file_like(&self) -> bool

Whether this merge is present and not a tree

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.

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.

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.

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, the executable bits and copy IDs from self will be preserved.

fn describe(&self, labels: &ConflictLabels) -> String

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

impl<T> PartialEq for Merge<T>

where T: PartialEq,

fn eq(&self, other: &Merge<T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T> Serialize for Merge<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for Merge<T>

where T: PartialEq,

impl<T> ToTreeMergeExt for Merge<Option<T>>

where T: Borrow<TreeValue>,

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.

impl TreeMergeExt for Merge<Tree>

fn dir(&self) -> &RepoPath

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

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.

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.

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

Look up the tree at the given path.