Struct oscen::signal::Rack

pub struct Rack {
    pub modules: HashMap<Tag, SynthModule>,
    pub order: Vec<Tag>,
}

A Rack is basically a HashMap of synth modules to be visited in the specified order.

Fields

modules: HashMap<Tag, SynthModule>

order: Vec<Tag>

Implementations

impl Rack

pub fn new(ws: Vec<ArcMutex<Sig>>) -> Self

Create a Rack object whose order is set to the order of the Signals in the input ws.

pub fn iter<'a>(&'a self) -> Iter<'a>ⓘ

Important traits for Iter<'a>

impl<'a> Iterator for Iter<'a> type Item = &'a SynthModule;

Convert a rack into an Iter - note: we don't need an iter_mut since we will mostly mutating a Node via it's Mutex.

pub fn out_tag(&self) -> Tag

Convenience function get the Tag of the final node in the Rack.

pub fn output(&self, n: Tag) -> Real

Get the output of a Node.

pub fn append(&mut self, sig: ArcMutex<Sig>)

Add a Node (synth module) to the Rack and set it's order to be last.

pub fn preppend(&mut self, sig: ArcMutex<Sig>)

Add a SynthModule to the Rack and set it's order to be first`.

pub fn before(&mut self, before: Tag, sig: ArcMutex<Sig>)

Add a SynthModule to the Rack at the position before was.

pub fn insert(&mut self, rack: Rack, loc: usize)

Insert a sub-rack into the rack before node loc.

pub fn signal(&mut self, sample_rate: Real) -> Real

A Rack generates a signal by travesing the list of modules and updating each one's output in turn. The output of the last Node is returned.

Trait Implementations

impl Clone for Rack

fn clone(&self) -> Rack

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> IntoIterator for &'a Rack

type Item = &'a SynthModule

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.