Enum StructOp 

pub enum StructOp {
    Replace {
        key: String,
        kind: NodeKind,
    },
    Insert {
        key: String,
        kind: NodeKind,
    },
    Delete {
        key: String,
    },
    SetMod {
        key: String,
        kind: ModKind,
    },
    SwapMix {
        key: String,
    },
    ReplaceTree {
        key: String,
        node: AudioNode,
    },
    InsertTree {
        key: String,
        node: AudioNode,
    },
    SetModTree {
        key: String,
        m: ModNode,
    },
}

One structural edit.

Variants

Replace

Replace the node at key with a kind (subtrees preserved where the sorts allow; replacing a source with a processor wraps the source).

Fields

key: String

Node key.

kind: NodeKind

New kind.

Insert

Insert a processor/mix between the node at key and its parent (i.e., into the wire toward the output).

Fields

key: String

Node key.

kind: NodeKind

Inserted kind (must not be a source).

Delete

Delete the node at key, splicing its (primary) input up.

Fields

key: String

Node key.

SetMod

Set the modulation slot of the module at key (everything but the two slotless binary nodes has one).

key addresses the audio module that owns the slot, not the slot itself. A source kind replaces the slot’s whole term; a shaper wraps it — see ModKind. To edit deeper into a chain, or to install one wholesale, use StructOp::SetModTree.

Fields

key: String

Node key.

kind: ModKind

New modulation kind.

SwapMix

Swap the two audio inputs of the binary node at key.

Named for the only production that accepted it when it was written; it now applies to all six two-input kinds, because “swap the two inputs” is a musical move on every one of them and the menu has always offered it on every one of them.

Fields

key: String

Node key.

ReplaceTree

Replace the subtree at key with an explicit fragment (the wire gesture “plug this staged chain in here, discard what was there” — callers park the old subtree client-side).

Fields

key: String

Node key.

node: AudioNode

The fragment to install.

InsertTree

Insert an explicit processor/mix fragment into the wire between key and its parent; the old subtree becomes the fragment’s primary input (a Mix keeps its own b branch).

Fields

key: String

Node key.

node: AudioNode

The fragment to graft in (must not be a source).

SetModTree

Install an explicit modulation fragment on the module at key.

Fields

key: String

Node key.

m: ModNode

The modulation term.

Trait Implementations

impl Clone for StructOp

fn clone(&self) -> StructOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StructOp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StructOp

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for StructOp

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for StructOp