Struct Outcome

pub struct Outcome<'a> {
    pub tree: Editor<'a>,
    pub conflicts: Vec<Conflict>,
    pub failed_on_first_unresolved_conflict: bool,
}

The outcome produced by tree().

Fields

tree: Editor<'a>

The ready-made (but unwritten) base tree, including all non-conflicting changes, and the changes that had conflicts which could be resolved automatically.

This means, if all of their changes were conflicting, this will be equivalent to the base tree.

conflicts: Vec<Conflict>

The set of conflicts we encountered. Can be empty to indicate there was no conflict. Note that conflicts might have been auto-resolved, but they are listed here for completeness. Use has_unresolved_conflicts() to see if any action is needed before using tree.

failed_on_first_unresolved_conflict: bool

true if conflicts contains only a single unresolved conflict in the last slot, but possibly more resolved ones. This also makes this outcome a very partial merge that cannot be completed. Only set if fail_on_conflict is true.

Implementations

impl Outcome<'_>

pub fn has_unresolved_conflicts(&self, how: TreatAsUnresolved) -> bool

Return true if there is any conflict that would still need to be resolved as they would yield undesirable trees. This is based on how to determine what should be considered unresolved.

pub fn index_changed_after_applying_conflicts( &self, index: &mut State, how: TreatAsUnresolved, ) -> bool

Returns true if index changed as we applied conflicting stages to it, using how to determine if a conflict should be considered unresolved. It’s important that index is at the state of Self::tree.

Note that in practice, whenever there is a single conflict, this function will return true. Also, the unconflicted stage of such entries will be removed merely by setting a flag, so the in-memory entry is still present.

Trait Implementations

impl<'a> Clone for Outcome<'a>

fn clone(&self) -> Outcome<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.