Enum PatchOp 

pub enum PatchOp {
    Insert {
        dest: RankedDest,
        node: PatchNode,
    },
    Put {
        slot: SlotRef,
        node: PatchNode,
    },
    Replace {
        target_id: NodeId,
        replacement: PatchNode,
    },
    Delete {
        target_id: NodeId,
    },
    Move {
        target_id: NodeId,
        dest: PatchDest,
    },
    Set {
        path: PatchPath,
        value: PatchValue,
    },
    Clear {
        path: PatchPath,
    },
    Attach {
        node_id: NodeId,
        target_id: NodeId,
    },
    Detach {
        node_id: NodeId,
    },
}

Structured patch operation over the Draxl semantic model.

Variants

Insert

Inserts a new child into a ranked slot.

Fields

dest: RankedDest

Ranked destination that owns the inserted child.

node: PatchNode

Node to insert.

Put

Fills or replaces a single-child slot.

Fields

slot: SlotRef

Slot to fill.

node: PatchNode

Node to install into the slot.

Replace

Rewrites an existing node payload while preserving its outer shell.

Fields

target_id: NodeId

Stable id of the node to rewrite.

replacement: PatchNode

Replacement fragment for the node body.

Delete

Removes an existing node.

Fields

target_id: NodeId

Stable id of the node to delete.

Move

Relocates an existing node while preserving its identity.

Fields

target_id: NodeId

Stable id of the node to move.

dest: PatchDest

New destination for the node.

Set

Updates a scalar field or metadata path.

Fields

path: PatchPath

Path to update.

value: PatchValue

New scalar value.

Clear

Clears an optional scalar field or metadata path.

Fields

path: PatchPath

Path to clear.

Attach

Attaches a doc or comment node to a semantic target.

Fields

node_id: NodeId

Attachable node id.

target_id: NodeId

Target node id.

Detach

Detaches a doc or comment node.

Fields

node_id: NodeId

Attachable node id.

Trait Implementations

impl Clone for PatchOp

fn clone(&self) -> PatchOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PatchOp

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

Formats the value using the given formatter.

impl PartialEq for PatchOp

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

impl StructuralPartialEq for PatchOp