use std::collections::VecDeque;
use std::sync::{Arc, Mutex};
pub const PARAMETER_EVENT_CAPACITY: usize = 256;
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum ParameterEvent {
Value {
id: u64,
normalized: f64,
},
BeginEdit {
id: u64,
},
EndEdit {
id: u64,
},
MetadataChanged,
ValuesChanged,
Dirty {
dirty: bool,
},
}
#[derive(Clone, Debug, Default, PartialEq)]
#[non_exhaustive]
#[must_use]
pub struct ParameterEventBatch {
pub events: Vec<ParameterEvent>,
pub resync_required: bool,
pub dropped: u64,
}
impl ParameterEventBatch {
#[doc(hidden)]
pub fn new(
events: Vec<ParameterEvent>,
resync_required: bool,
dropped: u64,
) -> ParameterEventBatch {
ParameterEventBatch {
events,
resync_required,
dropped,
}
}
}
struct Pending {
events: VecDeque<ParameterEvent>,
dropped: u64,
resync_required: bool,
}
impl Default for Pending {
fn default() -> Self {
Self {
events: VecDeque::with_capacity(PARAMETER_EVENT_CAPACITY),
dropped: 0,
resync_required: false,
}
}
}
impl Pending {
fn push(&mut self, event: ParameterEvent) {
match event {
ParameterEvent::MetadataChanged if self.events.contains(&event) => return,
ParameterEvent::ValuesChanged => self.events.retain(|queued| *queued != event),
_ => {}
}
if self.events.len() == PARAMETER_EVENT_CAPACITY {
let oldest = usize::from(self.events[0] == ParameterEvent::MetadataChanged);
self.events.remove(oldest);
self.dropped = self.dropped.saturating_add(1);
}
self.events.push_back(event);
}
}
#[derive(Clone, Default)]
pub struct ParameterEventBuffer(Arc<Mutex<Pending>>);
impl ParameterEventBuffer {
pub fn append(&self, batch: ParameterEventBatch) {
let mut pending = self.0.lock().unwrap_or_else(|error| error.into_inner());
pending.dropped = pending.dropped.saturating_add(batch.dropped);
pending.resync_required |= batch.resync_required;
for event in batch.events {
pending.push(event);
}
}
pub fn record(&self, event: ParameterEvent) {
let mut pending = self.0.lock().unwrap_or_else(|error| error.into_inner());
pending.push(event);
}
pub fn record_value(&self, id: u64, normalized: f64) {
let mut pending = self.0.lock().unwrap_or_else(|error| error.into_inner());
let last = pending.events.iter_mut().rev().find(|event| {
matches!(event,
ParameterEvent::Value { id: other, .. }
| ParameterEvent::BeginEdit { id: other }
| ParameterEvent::EndEdit { id: other } if *other == id)
|| **event == ParameterEvent::MetadataChanged
});
if let Some(ParameterEvent::Value {
normalized: queued, ..
}) = last
{
*queued = normalized;
return;
}
pending.push(ParameterEvent::Value { id, normalized });
}
pub fn take(&self) -> ParameterEventBatch {
let mut pending = self.0.lock().unwrap_or_else(|error| error.into_inner());
let dropped = std::mem::take(&mut pending.dropped);
ParameterEventBatch {
events: pending.events.drain(..).collect(),
resync_required: std::mem::take(&mut pending.resync_required) || dropped != 0,
dropped,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn shared_queue_preserves_gestures_and_reports_lost_continuity() {
let consumer = ParameterEventBuffer::default();
let producer = consumer.clone();
producer.record(ParameterEvent::BeginEdit { id: 3 });
for id in 0..PARAMETER_EVENT_CAPACITY as u64 {
producer.record(ParameterEvent::Value {
id,
normalized: 0.5,
});
}
producer.record(ParameterEvent::EndEdit { id: 3 });
let batch = consumer.take();
assert_eq!(batch.events.len(), PARAMETER_EVENT_CAPACITY);
assert_eq!(batch.dropped, 2);
assert!(batch.resync_required);
assert_eq!(
batch.events.first(),
Some(&ParameterEvent::Value {
id: 1,
normalized: 0.5
})
);
assert_eq!(
batch.events.last(),
Some(&ParameterEvent::EndEdit { id: 3 })
);
assert_eq!(consumer.take(), ParameterEventBatch::default());
}
#[test]
fn appending_preserves_upstream_loss_and_requery_requests() {
let buffer = ParameterEventBuffer::default();
buffer.append(ParameterEventBatch {
events: vec![ParameterEvent::MetadataChanged],
dropped: 4,
resync_required: true,
});
buffer.append(ParameterEventBatch {
events: vec![ParameterEvent::ValuesChanged],
dropped: 0,
resync_required: false,
});
let batch = buffer.take();
assert_eq!(
batch.events,
vec![
ParameterEvent::MetadataChanged,
ParameterEvent::ValuesChanged
]
);
assert_eq!(batch.dropped, 4);
assert!(batch.resync_required);
buffer.append(ParameterEventBatch {
events: Vec::new(),
dropped: 0,
resync_required: true,
});
assert!(buffer.take().resync_required);
}
#[test]
fn a_metadata_change_outlives_a_flood_of_values() {
let buffer = ParameterEventBuffer::default();
buffer.record(ParameterEvent::MetadataChanged);
for id in 0..2 * PARAMETER_EVENT_CAPACITY as u64 {
buffer.record(ParameterEvent::Value {
id,
normalized: 0.5,
});
}
buffer.record(ParameterEvent::MetadataChanged);
let batch = buffer.take();
assert_eq!(batch.events.len(), PARAMETER_EVENT_CAPACITY);
assert_eq!(batch.events[0], ParameterEvent::MetadataChanged);
assert_eq!(
batch
.events
.iter()
.filter(|event| **event == ParameterEvent::MetadataChanged)
.count(),
1
);
assert!(batch.resync_required);
}
#[test]
fn reported_values_replace_the_queued_one_up_to_a_gesture() {
let buffer = ParameterEventBuffer::default();
for normalized in [0.1, 0.2, 0.3] {
buffer.record_value(7, normalized);
buffer.record_value(8, normalized);
}
buffer.record(ParameterEvent::BeginEdit { id: 7 });
buffer.record_value(7, 0.4);
buffer.record_value(7, 0.5);
let value = |id, normalized| ParameterEvent::Value { id, normalized };
assert_eq!(
buffer.take().events,
[
value(7, 0.3),
value(8, 0.3),
ParameterEvent::BeginEdit { id: 7 },
value(7, 0.5)
]
);
}
#[test]
fn a_value_is_not_merged_across_a_metadata_change() {
let buffer = ParameterEventBuffer::default();
let value = |id, normalized| ParameterEvent::Value { id, normalized };
buffer.record_value(7, 0.1);
buffer.record(ParameterEvent::MetadataChanged);
buffer.record_value(7, 0.2);
assert_eq!(
buffer.take().events,
[
value(7, 0.1),
ParameterEvent::MetadataChanged,
value(7, 0.2)
]
);
}
#[test]
fn a_values_change_replaces_the_one_queued_before_it() {
let buffer = ParameterEventBuffer::default();
buffer.record(ParameterEvent::BeginEdit { id: 7 });
for _ in 0..2 * PARAMETER_EVENT_CAPACITY {
buffer.record_value(7, 0.5);
buffer.record_value(8, 0.5);
buffer.record(ParameterEvent::ValuesChanged);
}
buffer.record_value(7, 0.6);
let batch = buffer.take();
let value = |id, normalized| ParameterEvent::Value { id, normalized };
assert_eq!(
batch.events,
[
ParameterEvent::BeginEdit { id: 7 },
value(7, 0.6),
value(8, 0.5),
ParameterEvent::ValuesChanged
]
);
assert_eq!(batch.dropped, 0);
}
}