Enum TransactionOp 

#[non_exhaustive]
pub enum TransactionOp {
    Replace {
        node: NodeRef,
        source: String,
    },
    Insert {
        target: NodeRef,
        position: InsertPosition,
        source: String,
    },
    Remove {
        node: NodeRef,
    },
    If {
        condition: TransactionCondition,
        then: Vec<TransactionOp>,
        else_: Vec<TransactionOp>,
    },
}

A single operation within a transaction.

Ops are applied sequentially to an in-memory buffer. When mutating the same file multiple times, order ops by descending start_byte to avoid byte-offset drift.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Replace

Replace a node’s source text.

Fields

node: NodeRef

source: String

Insert

Insert source text relative to a target node.

Fields

target: NodeRef

The node to insert relative to.

position: InsertPosition

Where to insert: before, after, or into.

source: String

Source text to insert.

Remove

Remove a node.

Fields

node: NodeRef

If

Execute then if condition holds against the current buffer, else else.

Fields

condition: TransactionCondition

Condition to evaluate against the current in-memory buffer.

then: Vec<TransactionOp>

Ops to run if the condition is true.

else_: Vec<TransactionOp>

Ops to run if the condition is false. Empty means no-op.

Trait Implementations

impl Clone for TransactionOp

fn clone(&self) -> TransactionOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionOp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TransactionOp

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TransactionOp

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

where __S: Serializer,

Serialize this value into the given Serde serializer.