Struct RackModule 

pub struct RackModule {
    pub key: String,
    pub uid: u64,
    pub kind: String,
    pub title: String,
    pub column: usize,
    pub is_mod: bool,
    pub knobs: Vec<Knob>,
    pub structural_addrs: Vec<String>,
}

One module faceplate in the rack.

Fields

key: String

Trace key of the node (node, node/0, node/0/m, node/0/m/0, amp). A modulation chain’s stages nest under the slot with the same /0, /1 child convention the audio tree uses.

uid: u64

Stable node identity — Uid, flattened to its number, or 0 for the amp pseudo-module, which is the envelope wrapping the term rather than a node in it.

key is the wire protocol: it is what a StructOp names, what a trace address is built from, and what the engine understands. uid is the identity — the same module before and after an insert above it, a delete beside it, or a generation of refinement — and it is what the panel keys locks, hand positions and selection by. Anything that has to survive an edit is keyed by this; anything the engine has to read is keyed by key.

kind: String

Machine kind tag (vco, filter, lfo, amp, …).

title: String

Silkscreen title.

column: usize

Distance from the root (root = 0); layout hint for column placement.

is_mod: bool

True for modulation-sort modules — the ones that live at or below a <key>/m slot rather than in the audio path.

As of wave 2C that is a whole sort rather than four leaves: the generators (lfo, mod env, s&h rand, follower, euclid), the CV processors that wrap them (quantize, slew, rectify, hold) and the combiners that join two (min, max, and, or, xor, switch). A chain is drawn as a run of modules with mod wires between them, each one column further from the destination.

knobs: Vec<Knob>

The knobs, in faceplate order.

structural_addrs: Vec<String>

Structural choice addresses owned by this module (#leaf, #src, #op, #mod, and any empty mod slot it guards). Locking the module means locking these plus all knob addresses — evolution can then not replace or restructure it.

Trait Implementations

impl Clone for RackModule

fn clone(&self) -> RackModule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RackModule

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RackModule

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RackModule

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

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 RackModule