Struct jj_lib::conflicts::Conflict

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

A generic representation of conflicting values.

There is exactly one more adds() than removes(). When interpreted as a series of diffs, the conflict’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> Conflict<T>

pub fn new(removes: Vec<T>, adds: Vec<T>) -> Self

pub fn resolved(value: T) -> Self

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

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

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

Returns the removes and adds as a pair.

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

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

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

Returns the resolved value, if this conflict is resolved. Does not resolve trivial conflicts.

pub fn simplify(self) -> Selfwhere T: PartialEq,

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

pub fn resolve_trivial(&self) -> Option<&T>where T: Eq + Hash,

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

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

pub fn maybe_map<'a, U>( &'a self, f: impl FnMut(&'a T) -> Option<U> ) -> Option<Conflict<U>>

Creates a new conflict by applying f to each remove and add, returning None if freturnsNone` for any of them.

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

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

impl<T> Conflict<Option<T>>

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

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

impl<T> Conflict<Conflict<T>>

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

Flattens a nested conflict into a regular conflict.

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 conflict:

4 5 0 7 8 3 2 1 6

impl Conflict<Option<TreeValue>>

pub fn from_backend_conflict(conflict: Conflict) -> Self

Create a Conflict 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 Conflict by dropping None values. Note that the conversion is lossy: the order of None values is not preserved when converting back to a Conflict.

pub fn materialize( &self, store: &Store, path: &RepoPath, output: &mut dyn Write ) -> Result<()>

pub fn to_file_conflict(&self) -> Option<Conflict<Option<FileId>>>

pub fn describe(&self, file: &mut dyn Write) -> Result<()>

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

pub fn update_from_content( &self, store: &Store, path: &RepoPath, content: &[u8] ) -> BackendResult<Option<Conflict<Option<TreeValue>>>>

Returns None if there are no conflict markers in content.

impl Conflict<Option<FileId>>

pub fn extract_as_single_hunk( &self, store: &Store, path: &RepoPath ) -> Conflict<ContentHunk>

Trait Implementations

impl<T: Clone> Clone for Conflict<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Conflict<T>

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

Formats the value using the given formatter.

impl<T: Hash> Hash for Conflict<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: PartialEq> PartialEq<Conflict<T>> for Conflict<T>

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

impl<T> StructuralEq for Conflict<T>

impl<T> StructuralPartialEq for Conflict<T>