Struct Preset 

pub struct Preset {
    pub name: String,
    pub description: String,
    pub author: Option<String>,
    pub tags: Vec<String>,
    pub nodes: Vec<NodeConfig>,
    pub connections: Vec<Connection>,
    pub metadata: HashMap<String, String>,
}

A complete preset containing graph structure and parameter values.

Example

use aether_core::preset::Preset;

let mut preset = Preset::new("My Synth", "A simple synthesizer");

// Add nodes
preset.add_node(0, "Oscillator");
preset.add_node(1, "Filter");
preset.add_node(2, "Gain");

// Add connections
preset.add_connection(0, 1, 0); // Osc -> Filter
preset.add_connection(1, 2, 0); // Filter -> Gain

// Set parameters
preset.set_param(0, 0, 440.0); // Oscillator frequency
preset.set_param(1, 0, 1000.0); // Filter cutoff
preset.set_param(2, 0, 0.75); // Gain level

// Serialize to JSON
let json = preset.to_json().unwrap();
println!("{}", json);

// Deserialize from JSON
let loaded = Preset::from_json(&json).unwrap();
assert_eq!(loaded.name, "My Synth");

Fields

name: String

Preset name

description: String

Preset description

author: Option<String>

Author name (optional)

tags: Vec<String>

Tags for categorization

nodes: Vec<NodeConfig>

Nodes in the graph

connections: Vec<Connection>

Connections between nodes

metadata: HashMap<String, String>

Metadata (BPM, key, etc.)

Implementations

impl Preset

pub fn new(name: impl Into<String>, description: impl Into<String>) -> Self

Creates a new empty preset.

Arguments

• name - Preset name
• description - Preset description

Example

use aether_core::preset::Preset;

let preset = Preset::new("Bass Synth", "Deep bass synthesizer");
assert_eq!(preset.name, "Bass Synth");
assert_eq!(preset.nodes.len(), 0);

pub fn add_node(&mut self, id: usize, node_type: impl Into<String>)

Adds a node to the preset.

Arguments

• id - Node ID (unique within preset)
• node_type - Node type name

Example

use aether_core::preset::Preset;

let mut preset = Preset::new("Test", "Test preset");
preset.add_node(0, "Oscillator");
preset.add_node(1, "Filter");
assert_eq!(preset.nodes.len(), 2);

pub fn add_connection(&mut self, src_id: usize, dst_id: usize, slot: usize)

Adds a connection between two nodes.

Arguments

• src_id - Source node ID
• dst_id - Destination node ID
• slot - Input slot on destination node

Example

use aether_core::preset::Preset;

let mut preset = Preset::new("Test", "Test preset");
preset.add_node(0, "Oscillator");
preset.add_node(1, "Filter");
preset.add_connection(0, 1, 0); // Osc -> Filter input 0
assert_eq!(preset.connections.len(), 1);

pub fn set_param(&mut self, node_id: usize, param_index: usize, value: f32)

Sets a parameter value for a node.

Arguments

• node_id - Node ID
• param_index - Parameter index
• value - Parameter value

Example

use aether_core::preset::Preset;

let mut preset = Preset::new("Test", "Test preset");
preset.add_node(0, "Oscillator");
preset.set_param(0, 0, 440.0); // Set frequency to 440 Hz
preset.set_param(0, 1, 0.5);   // Set amplitude to 0.5

pub fn set_position(&mut self, node_id: usize, x: f32, y: f32)

Sets the UI position for a node.

Arguments

• node_id - Node ID
• x - X coordinate
• y - Y coordinate

pub fn add_tag(&mut self, tag: impl Into<String>)

Adds a tag to the preset.

Arguments

• tag - Tag to add

Example

use aether_core::preset::Preset;

let mut preset = Preset::new("Bass", "Deep bass");
preset.add_tag("bass");
preset.add_tag("synth");
preset.add_tag("electronic");
assert_eq!(preset.tags.len(), 3);

pub fn set_metadata(&mut self, key: impl Into<String>, value: impl Into<String>)

Sets metadata key-value pair.

Arguments

• key - Metadata key
• value - Metadata value

Example

use aether_core::preset::Preset;

let mut preset = Preset::new("Song", "Song preset");
preset.set_metadata("bpm", "120");
preset.set_metadata("key", "C minor");

pub fn to_json(&self) -> Result<String, Error>

Serializes the preset to JSON.

Returns

JSON string representation of the preset.

Errors

Returns an error if serialization fails.

Example

use aether_core::preset::Preset;

let mut preset = Preset::new("Test", "Test preset");
preset.add_node(0, "Oscillator");
let json = preset.to_json().unwrap();
assert!(json.contains("\"name\":\"Test\""));

pub fn from_json(json: &str) -> Result<Self, Error>

Deserializes a preset from JSON.

Arguments

• json - JSON string

Returns

Deserialized preset.

Errors

Returns an error if deserialization fails.

Example

use aether_core::preset::Preset;

let json = r#"{
  "name": "Test",
  "description": "Test preset",
  "nodes": [],
  "connections": []
}"#;

let preset = Preset::from_json(json).unwrap();
assert_eq!(preset.name, "Test");

pub fn validate(&self) -> Result<(), String>

Validates the preset structure.

Checks for:

• Duplicate node IDs
• Invalid connections (referencing non-existent nodes)
• Empty preset name

Returns

Ok(()) if valid, Err(String) with error message if invalid.

Example

use aether_core::preset::Preset;

let mut preset = Preset::new("Test", "Test preset");
preset.add_node(0, "Oscillator");
preset.add_node(1, "Filter");
preset.add_connection(0, 1, 0);
assert!(preset.validate().is_ok());

// Invalid connection
preset.add_connection(0, 99, 0); // Node 99 doesn't exist
assert!(preset.validate().is_err());

Trait Implementations

impl Clone for Preset

fn clone(&self) -> Preset

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Preset

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Preset

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Preset

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

where __S: Serializer,

Serialize this value into the given Serde serializer.