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>,
computations: Vec<engine::Computation>,
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
}
#[cfg(all(test, unix))]
pub(crate) fn vcd_index_queries(&self) -> Option<usize> {
match &self.waveform.reader {
crate::backends::Reader::Vcd(reader) => Some(
reader
.index_queries
.load(std::sync::atomic::Ordering::Relaxed),
),
_ => None,
}
}
#[cfg(all(test, unix))]
pub(crate) fn vcd_traversal_queries(&self) -> Option<usize> {
match &self.waveform.reader {
crate::backends::Reader::Vcd(reader) => Some(
reader
.traversal_queries
.load(std::sync::atomic::Ordering::Relaxed),
),
_ => None,
}
}
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(sample.to_owned());
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);
}
if let crate::backends::Reader::Vcd(reader) = &self.waveform.reader
&& let Some(result) =
reader.candidate_times(&self.bases, range.start(), end, &mut visitor)
{
return Ok(result);
}
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 to_owned(self) -> Sample {
match self {
Self::Missing { signal } => Sample::Missing { signal },
Self::Value {
signal,
value,
changed_at,
} => Sample::Value {
signal,
value: value.to_owned(),
changed_at,
},
Self::Event {
signal,
occurrences,
} => Sample::Event {
signal,
occurrences,
},
}
}
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 sample(&self, time: Time) -> Result<SampleRef<'_>> {
if self.range.is_empty()
|| time < self.range.start()
|| self.range.end().is_some_and(|end| time > end)
{
return Err(crate::Error::TraceCoverage {
requested: time,
range: self.range,
});
}
let index = self.changes.partition_point(|change| change.time <= time);
let change = index.checked_sub(1).map(|index| &self.changes[index]);
if self.signal.encoding() == crate::Encoding::Event {
let occurrences = match change
.filter(|change| change.time == time)
.map(Change::value)
{
Some(ValueRef::Event { occurrences }) => occurrences,
_ => 0,
};
return Ok(SampleRef::Event {
signal: self.signal,
occurrences,
});
}
if let Some(change) = change {
return Ok(SampleRef::Value {
signal: self.signal,
value: change.value(),
changed_at: (index > 1 || self.initial.is_some()).then_some(change.time),
});
}
Ok(match &self.initial {
Some(initial) => SampleRef::Value {
signal: self.signal,
value: initial.value(),
changed_at: initial.changed_at,
},
None => SampleRef::Missing {
signal: self.signal,
},
})
}
pub fn samples_at(&self, times: &[Time]) -> Result<Vec<(Time, SampleRef<'_>)>> {
times
.iter()
.map(|&time| self.sample(time).map(|sample| (time, sample)))
.collect()
}
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
}
}