simplify further schedule helper

Author: valsteen

note_off_delay/src/lib.rs

@@ -15,9 +15,8 @@ use vst::plugin::{CanDo, Category, HostCallback, Info, Plugin};
 use crate::parameters::PARAMETER_COUNT;
 use parameters::NoteOffDelayPluginParameters;
 use parameters::Parameter;
-use std::mem::take;
 use util::absolute_time_midi_message_vector::AbsoluteTimeMidiMessageVector;
-use util::delayed_message_consumer::{MessageReason, ScheduledEventsHelper};
+use util::delayed_message_consumer::{process_scheduled_events, MessageReason};
 use util::logging::logging_setup;
 use util::messages::format_event;
 use util::midi_message_type::MidiMessageType;
@@ -48,19 +47,20 @@ impl Default for NoteOffDelayPlugin {
 impl NoteOffDelayPlugin {
     fn send_events(&mut self, samples: usize) {
         if let Ok(mut host_callback_lock) = self.parameters.host_mutex.lock() {
-            let mut helper = ScheduledEventsHelper::new(
+            let (queued_messages, events) = process_scheduled_events(
                 samples,
                 self.parameters.get_delay().is_active(),
                 self.parameters.get_max_notes(),
                 self.parameters
                     .get_bool_parameter(Parameter::MaxNotesAppliesToDelayedNotesOnly),
                 self.current_time_in_samples,
+                &self.message_queue,
             );
-            helper.process_scheduled_events(&self.message_queue);
-            self.message_queue = take(&mut helper.queued_messages);
+
+            self.message_queue = queued_messages;
             self.send_buffer
                 .borrow_mut()
-                .send_events(helper.events, &mut host_callback_lock.host);
+                .send_events(events, &mut host_callback_lock.host);
         }
     }
 

util/src/delayed_message_consumer.rs

@@ -82,20 +82,46 @@ impl PlayingNotes {
     }
 }
 
-pub struct ScheduledEventsHelper {
+struct ScheduledEventsHelper {
     playing_notes: PlayingNotes,
-    pub queued_messages: AbsoluteTimeMidiMessageVector,
+    queued_messages: AbsoluteTimeMidiMessageVector,
     notes_on_to_requeue: HashMap<usize, AbsoluteTimeMidiMessage>,
-    pub events: Vec<MidiEvent>,
+    events: Vec<MidiEvent>,
     buffer_duration_in_samples: usize,
     delay_is_active: bool,
     max_notes: MaxNotesParameter,
     apply_max_notes_to_delayed_notes_only: bool,
     current_time_in_samples: usize,
 }
 
+pub fn process_scheduled_events(
+    buffer_duration_in_samples: usize,
+    delay_is_active: bool,
+    max_notes: MaxNotesParameter,
+    apply_max_notes_to_delayed_notes_only: bool,
+    current_time_in_samples: usize,
+    messages: &AbsoluteTimeMidiMessageVector,
+) -> (AbsoluteTimeMidiMessageVector, Vec<MidiEvent>) {
+    let mut helper = ScheduledEventsHelper::new(
+        buffer_duration_in_samples,
+        delay_is_active,
+        max_notes,
+        apply_max_notes_to_delayed_notes_only,
+        current_time_in_samples,
+    );
+    helper.process_scheduled_events(messages);
+
+    let ScheduledEventsHelper {
+        events,
+        queued_messages,
+        ..
+    } = helper;
+
+    (queued_messages, events)
+}
+
 impl ScheduledEventsHelper {
-    pub fn new(
+    fn new(
         buffer_duration_in_samples: usize,
         delay_is_active: bool,
         max_notes: MaxNotesParameter,
@@ -174,7 +200,7 @@ impl ScheduledEventsHelper {
         }
     }
 
-    pub fn process_scheduled_events(&mut self, messages: &AbsoluteTimeMidiMessageVector) {
+    fn process_scheduled_events(&mut self, messages: &AbsoluteTimeMidiMessageVector) {
         for mut message in messages.iter().copied() {
             if message.play_time_in_samples < self.current_time_in_samples {
                 match MidiMessageType::from(message) {