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

where T: PartialEq,

Updates the merge based on the given simplified merge.

pub fn resolve_trivial(&self) -> 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 Merge<Option<TreeValue>>

pub fn from_backend_conflict(conflict: Conflict) -> Self

Create a Merge from a backend::Conflict, padding with None to make sure that there is exactly one more adds() than removes().

pub fn into_backend_conflict(self) -> Conflict

Creates a backend::Conflict 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: Borrow<TreeValue>,

pub fn is_tree(&self) -> bool

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

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”

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

impl<T> StructuralPartialEq for Merge<T>