Struct ReconciliationPlan 

pub struct ReconciliationPlan {
    pub left_id: StateId,
    pub right_id: StateId,
    pub base_id: StateId,
    pub parent_choice: bool,
    pub path_overrides: BTreeMap<Vec<PathComponent>, Value>,
}

Reconciliation plan specifying how to merge two branches

Fields

left_id: StateId

Left (first) branch revision

right_id: StateId

Right (second) branch revision

base_id: StateId

Common ancestor revision

parent_choice: bool

Which branch to use as primary: true for left, false for right

path_overrides: BTreeMap<Vec<PathComponent>, Value>

Override values for specific paths (caller-supplied)

Implementations

impl ReconciliationPlan

pub fn new( left_id: StateId, right_id: StateId, base_id: StateId, parent_choice: bool, ) -> Self

Create reconciliation plan with explicit parent choice

pub fn with_override(self, path: Vec<PathComponent>, value: Value) -> Self

Add override for a specific path

pub fn validate(&self) -> bool

Validate that plan references valid states

impl ReconciliationPlan

pub fn selected_parent<'a>( &self, left: &'a StateRevision, right: &'a StateRevision, ) -> &'a StateRevision

The branch this plan selects as the state to start from.

parent_choice is a bool and so has exactly two values: true is the left branch, false the right. The ancestor is not a choice, and there is no third value for this to reject.

pub fn unresolved_conflicts( &self, classification: &ConflictClassification, ) -> Vec<Vec<PathComponent>>

The conflicting paths this plan supplies no override for.

Descriptive, not enforced. Application does not require an override for every conflict: leaving one unaddressed resolves it to whatever the selected parent holds, and selecting that parent is itself an explicit caller decision. A caller that wants every conflict addressed individually can require this to be empty before applying.

Trait Implementations

impl Clone for ReconciliationPlan

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReconciliationPlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReconciliationPlan

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ReconciliationPlan

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

where __S: Serializer,

Serialize this value into the given Serde serializer.