Struct ProcEvents 

pub struct ProcEvents<'a> { /* private fields */ }

A list of events for an AudioNodeProcessor.

Implementations

impl<'a> ProcEvents<'a>

pub fn new( immediate_event_buffer: &'a mut [Option<NodeEvent>], scheduled_event_arena: &'a mut [Option<ScheduledEventEntry>], indices: &'a mut Vec<ProcEventsIndex>, ) -> Self

pub fn num_events(&self) -> usize

pub fn drain<'b>( &'b mut self, ) -> impl IntoIterator<Item = NodeEventType> + use<'b>

Iterate over all events, draining the events from the list.

pub fn drain_with_timestamps<'b>( &'b mut self, ) -> impl IntoIterator<Item = (NodeEventType, Option<EventInstant>)> + use<'b>

Iterate over all events and their timestamps, draining the events from the list.

The iterator returns (event_type, Option<event_instant>) where event_type is the event, event_instant is the instant the event was schedueld for. If the event was not scheduled, then the latter will be None.

pub fn drain_patches<'b, T: Patch>( &'b mut self, ) -> impl IntoIterator<Item = <T as Patch>::Patch> + use<'b, T>

Iterate over patches for T, draining the events from the list.

#[derive(Patch, Default)]
struct FilterNode {
    frequency: f32,
    quality: f32,
}

let mut node = FilterNode::default();

// You can match on individual patch variants.
for patch in event_list.drain_patches::<FilterNode>() {
    match patch {
        FilterNodePatch::Frequency(frequency) => {
            node.frequency = frequency;
        }
        FilterNodePatch::Quality(quality) => {
            node.quality = quality;
        }
    }
}

// Or simply apply all of them.
for patch in event_list.drain_patches::<FilterNode>() { node.apply(patch); }

Errors produced while constructing patches are simply skipped.

pub fn drain_patches_with_timestamps<'b, T: Patch>( &'b mut self, ) -> impl IntoIterator<Item = (<T as Patch>::Patch, Option<EventInstant>)> + use<'b, T>

Iterate over patches for T, draining the events from the list, while also returning the timestamp the event was scheduled for.

The iterator returns (patch, Option<event_instant>) where event_instant is the instant the event was schedueld for. If the event was not scheduled, then the latter will be None.

#[derive(Patch, Default)]
struct FilterNode {
    frequency: f32,
    quality: f32,
}

let mut node = FilterNode::default();

// You can match on individual patch variants.
for (patch, timestamp) in event_list.drain_patches_with_timestamps::<FilterNode>() {
    match patch {
        FilterNodePatch::Frequency(frequency) => {
            node.frequency = frequency;
        }
        FilterNodePatch::Quality(quality) => {
            node.quality = quality;
        }
    }
}

// Or simply apply all of them.
for (patch, timestamp) in event_list.drain_patches_with_timestamps::<FilterNode>() { node.apply(patch); }

Errors produced while constructing patches are simply skipped.