1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
//! Definition of the current state of the graph modeled in the UI. //! //! # Example //! //! The following example represents a possible report returned from an //! application instantiated via the [`Config` //! example](../config/index.html#example). Note that it is not a valid rust //! code, but an output of the `dbg!` macro. //! //! ```ignore //! Report { //! nodes: [ //! Node { //! id: "comment:0", //! class: "comment", //! data: { //! "comment": String( //! "Content of the comment block.", //! ), //! }, //! }, //! Node { //! id: "oscillator:0", //! class: "oscillator", //! data: { //! "switch": Bool( //! true, //! ), //! "trigger": Bool( //! false, //! ), //! "dropdown": String( //! "triangle", //! ), //! "slider": F32( //! 7.5, //! ), //! }, //! }, //! Node { //! id: "mixer:0", //! class: "mixer", //! data: {}, //! }, //! ], //! patches: [ //! Patch { //! source: PinAddress { //! node_id: "oscillator:0", //! pin_class: "output", //! }, //! destination: PinAddress { //! node_id: "mixer:0", //! pin_class: "input1", //! }, //! }, //! ], //! } //! ``` use std::collections::HashMap; /// Report is a structure holding information about the current "model" of the /// graph represented in the UI. It does not report details about the widgets /// that were used nor about positions of items on the canvas. It is limited to /// the minimal amount of information needed to convert the state into a graph. #[derive(Debug)] pub struct Report { /// All instantiated notes with their values set via widgets. pub nodes: Vec<Node>, /// List of all patches connecting node pins. pub patches: Vec<Patch>, } /// A structure representing an existing node and its associated values. #[derive(Debug)] pub struct Node { /// Unique identificator of this node. pub id: String, /// Class references the node template this node was instantiated from. pub class: String, /// Map of all the values set via widgets available on the node. The key is /// always the key of the given widget as defined in the node template. pub data: HashMap<String, Value>, } /// Enum encapsulating possible values of an item attached to a node. #[derive(Debug)] pub enum Value { String(String), F32(f32), Bool(bool), } impl Value { /// Access string value stored in the enum. /// /// # Panics /// /// Panics if the variant is not `String`. pub fn unwrap_string(&self) -> &str { if let Self::String(value) = self { &value } else { panic!("The value is not of type String"); } } /// Access f32 value stored in the enum. /// /// # Panics /// /// Panics if the variant is not `F32`. pub fn unwrap_f32(&self) -> f32 { if let Self::F32(value) = self { *value } else { panic!("The value is not of type F32"); } } /// Access bool value stored in the enum. /// /// # Panics /// /// Panics if the variant is not `Bool`. pub fn unwrap_bool(&self) -> bool { if let Self::Bool(value) = self { *value } else { panic!("The value is not of type Bool"); } } } /// A structure representing a patch between two pins of available nodes. #[derive(Debug)] pub struct Patch { /// Output pin where the patch originates from. pub source: PinAddress, /// Input pin where the patch leads into. pub destination: PinAddress, } /// Uniquely represents a pin by referencing node by its ID an pin by /// its class. #[derive(Debug)] pub struct PinAddress { pub node_id: String, pub pin_class: String, }