use std::{collections::HashMap, ops::ControlFlow};
use crate::{Hierarchy, Result, Signal, Time, TimeRange, Value, ValueRef, Waveform};
mod engine;
#[cfg(test)]
mod tests;
pub struct Selection<'w> {
waveform: &'w mut Waveform,
signals: Vec<Signal>,
bases: Vec<Signal>,
groups: HashMap<usize, Vec<usize>>,
slot_indices: Vec<usize>,
retained_signals: Vec<Signal>,
replay: Option<engine::Replay>,
checkpoint: Option<engine::Replay>,
}
pub struct QueryContext<'a> {
time: Time,
signals: &'a [Signal],
slots: &'a [engine::Slot],
slot_indices: &'a [usize],
previous_tick: Option<Time>,
previous_events: &'a [u64],
}
impl Selection<'_> {
pub fn signals(&self) -> &[Signal] {
&self.signals
}
pub fn hierarchy(&self) -> &Hierarchy {
self.waveform.hierarchy()
}
pub fn samples(&mut self, time: Time) -> Result<Vec<Sample>> {
let mut samples = Vec::with_capacity(self.signals.len());
let _ = self.visit_samples(time, |sample| {
samples.push(match sample {
SampleRef::Missing { signal } => Sample::Missing { signal },
SampleRef::Value {
signal,
value,
changed_at,
} => Sample::Value {
signal,
value: value.to_owned(),
changed_at,
},
SampleRef::Event {
signal,
occurrences,
} => Sample::Event {
signal,
occurrences,
},
});
ControlFlow::<()>::Continue(())
})?;
Ok(samples)
}
pub fn traces(&mut self, range: TimeRange) -> Result<Vec<Trace>> {
let mut traces = self
.signals
.iter()
.map(|&signal| Trace {
signal,
range,
initial: None,
changes: Vec::new(),
})
.collect::<Vec<_>>();
let _ = self.scan_each(range, |index, record| {
match record {
ScanRef::Initial {
value, changed_at, ..
} => {
traces[index].initial = Some(Initial {
value: value.to_owned(),
changed_at,
})
}
ScanRef::Change { time, value, .. } => traces[index].changes.push(Change {
time,
value: value.to_owned(),
}),
}
ControlFlow::<()>::Continue(())
})?;
Ok(traces)
}
pub fn visit_samples<B>(
&mut self,
time: Time,
visitor: impl for<'v> FnMut(SampleRef<'v>) -> ControlFlow<B>,
) -> Result<ControlFlow<B>> {
self.sample_visit(time, visitor)
}
pub fn scan<B>(
&mut self,
range: TimeRange,
mut visitor: impl for<'v> FnMut(ScanRef<'v>) -> ControlFlow<B>,
) -> Result<ControlFlow<B>> {
self.scan_each(range, |_, record| visitor(record))
}
pub fn scan_candidate_times<B>(
&mut self,
range: TimeRange,
mut visitor: impl FnMut(Time) -> ControlFlow<B>,
) -> Result<ControlFlow<B>> {
let end = range
.end()
.or_else(|| self.waveform.metadata().time_span().map(|span| span.last()))
.unwrap_or(Time::from_ticks(u64::MAX));
if let crate::backends::Reader::Fst(reader) = &mut self.waveform.reader {
return reader.read_candidate_times(&self.bases, range.start(), end, visitor);
}
let mut last = None;
self.scan(range, |record| {
if let ScanRef::Change { time, .. } = record
&& last != Some(time)
{
last = Some(time);
return visitor(time);
}
ControlFlow::Continue(())
})
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub enum Sample {
Missing {
signal: Signal,
},
Value {
signal: Signal,
value: Value,
changed_at: Option<Time>,
},
Event {
signal: Signal,
occurrences: u64,
},
}
#[derive(Debug, Clone, Copy)]
#[non_exhaustive]
pub enum SampleRef<'a> {
Missing {
signal: Signal,
},
Value {
signal: Signal,
value: ValueRef<'a>,
changed_at: Option<Time>,
},
Event {
signal: Signal,
occurrences: u64,
},
}
impl Sample {
pub fn signal(&self) -> Signal {
self.as_ref().signal()
}
pub fn as_ref(&self) -> SampleRef<'_> {
match self {
Self::Missing { signal } => SampleRef::Missing { signal: *signal },
Self::Value {
signal,
value,
changed_at,
} => SampleRef::Value {
signal: *signal,
value: value.as_ref(),
changed_at: *changed_at,
},
Self::Event {
signal,
occurrences,
} => SampleRef::Event {
signal: *signal,
occurrences: *occurrences,
},
}
}
}
impl SampleRef<'_> {
pub fn signal(self) -> Signal {
match self {
Self::Missing { signal } | Self::Value { signal, .. } | Self::Event { signal, .. } => {
signal
}
}
}
}
#[derive(Debug, Clone, Copy)]
#[non_exhaustive]
pub enum ScanRef<'a> {
Initial {
signal: Signal,
value: ValueRef<'a>,
changed_at: Option<Time>,
},
Change {
signal: Signal,
time: Time,
value: ValueRef<'a>,
},
}
pub struct Initial {
value: Value,
changed_at: Option<Time>,
}
pub struct Change {
time: Time,
value: Value,
}
pub struct Trace {
signal: Signal,
range: TimeRange,
initial: Option<Initial>,
changes: Vec<Change>,
}
impl Initial {
pub fn value(&self) -> ValueRef<'_> {
self.value.as_ref()
}
pub fn changed_at(&self) -> Option<Time> {
self.changed_at
}
}
impl Change {
pub fn time(&self) -> Time {
self.time
}
pub fn value(&self) -> ValueRef<'_> {
self.value.as_ref()
}
}
impl Trace {
pub fn signal(&self) -> Signal {
self.signal
}
pub fn range(&self) -> TimeRange {
self.range
}
pub fn initial(&self) -> Option<&Initial> {
self.initial.as_ref()
}
pub fn changes(&self) -> &[Change] {
&self.changes
}
}