Enum PersistentApplyError 

pub enum PersistentApplyError {
    MissingNode {
        node_id: PaneId,
    },
    NotSplit {
        node_id: PaneId,
    },
    NotLeaf {
        node_id: PaneId,
    },
    CannotCloseRoot {
        node_id: PaneId,
    },
    AncestorConflict {
        ancestor: PaneId,
        descendant: PaneId,
    },
    IdOverflow {
        current: PaneId,
    },
    InvalidTree(PaneModelError),
    Rebuild(String),
}

Failure from VersionedPaneTree::apply_operation.

The variants mirror the canonical baseline’s reject conditions closely enough that the differential oracle only needs accept/reject agreement plus state-hash equality on the accept path.

Variants

MissingNode

Referenced node id is absent from the tree.

Fields

node_id: PaneId

The missing node id.

NotSplit

Operation targeted a non-split node where a split was required.

Fields

node_id: PaneId

The offending node id.

NotLeaf

Operation targeted a non-leaf node where a leaf was required.

Fields

node_id: PaneId

The offending node id.

CannotCloseRoot

Attempted to close the root node.

Fields

node_id: PaneId

The root id.

AncestorConflict

One node is an ancestor of the other (illegal for swap).

Fields

ancestor: PaneId

The ancestor node.

descendant: PaneId

The descendant node.

IdOverflow

Ran out of the pane id space.

Fields

current: PaneId

The id at which allocation failed.

InvalidTree(PaneModelError)

The flattened tree failed canonical validation (should be unreachable).

Rebuild(String)

The rebuild-fallback baseline rejected the operation.

Trait Implementations

impl Clone for PersistentApplyError

fn clone(&self) -> PersistentApplyError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PersistentApplyError

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

Formats the value using the given formatter.

impl Eq for PersistentApplyError

impl PartialEq for PersistentApplyError

fn eq(&self, other: &PersistentApplyError) -> 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 StructuralPartialEq for PersistentApplyError