Yehowshua/FastWaveBackend
1
0
Fork 0
Code Issues 9 Pull requests 1 Actions Packages Projects Releases Wiki Activity

Merge pull request #14 from TheZoq2/main

Browse source 
Add real_idx function to signal
This commit is contained in:
Frans Skarman 2023-09-19 12:59:18 +00:00 committed by GitHub
parent 14a314a2f3 878b06e666
commit de6fae83c4
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 53 additions and 50 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

81
src/vcd/signal.rs
View file

@ -2,8 +2,8 @@
// This program is distributed under both the GPLV3 license // This program is distributed under both the GPLV3 license
// and the YEHOWSHUA license, both of which can be found at // and the YEHOWSHUA license, both of which can be found at
// the root of the folder containing the sources for this program. // the root of the folder containing the sources for this program.
use super::types::SignalIdx;
use super::types; use super::types;
use super::types::SignalIdx;
use num::BigUint; use num::BigUint;
// Index to the least significant byte of a timestamp // Index to the least significant byte of a timestamp
@ -39,11 +39,18 @@ impl<'a> Signal<'a> {
pub fn path(&self) -> &[String] { pub fn path(&self) -> &[String] {
match self.0 { match self.0 {
SignalEnum::Data {path, ..} => path, SignalEnum::Data { path, .. } => path,
SignalEnum::Alias { path, .. } => path, SignalEnum::Alias { path, .. } => path,
} }
} }
pub fn real_idx(&self) -> SignalIdx {
match self.0 {
SignalEnum::Data { self_idx, .. } => *self_idx,
SignalEnum::Alias { signal_alias, .. } => *signal_alias,
}
}
pub fn num_bits(&self) -> Option<u16> { pub fn num_bits(&self) -> Option<u16> {
let Signal(signal_enum) = &self; let Signal(signal_enum) = &self;
signal_enum.bits_required() signal_enum.bits_required()
@ -55,7 +62,9 @@ impl<'a> Signal<'a> {
vcd: &types::VCD, vcd: &types::VCD,
) -> Result<String, SignalErrors> { ) -> Result<String, SignalErrors> {
let Signal(signal_enum) = &self; let Signal(signal_enum) = &self;
signal_enum.query_string_val_on_tmln(desired_time, &vcd.tmstmps_encoded_as_u8s, &vcd.all_signals).map(|(val, _)| val) signal_enum
.query_string_val_on_tmln(desired_time, &vcd.tmstmps_encoded_as_u8s, &vcd.all_signals)
.map(|(val, _)| val)
} }
pub fn query_num_val_on_tmln( pub fn query_num_val_on_tmln(
&self, &self,
@ -63,7 +72,9 @@ impl<'a> Signal<'a> {
vcd: &types::VCD, vcd: &types::VCD,
) -> Result<BigUint, SignalErrors> { ) -> Result<BigUint, SignalErrors> {
let Signal(signal_enum) = &self; let Signal(signal_enum) = &self;
signal_enum.query_num_val_on_tmln(desired_time, &vcd.tmstmps_encoded_as_u8s, &vcd.all_signals).map(|(val, _)| val) signal_enum
.query_num_val_on_tmln(desired_time, &vcd.tmstmps_encoded_as_u8s, &vcd.all_signals)
.map(|(val, _)| val)
} }
pub fn query_val_on_tmln( pub fn query_val_on_tmln(
@ -72,18 +83,16 @@ impl<'a> Signal<'a> {
vcd: &types::VCD, vcd: &types::VCD,
) -> Result<(TimeStamp, SignalValue), SignalErrors> { ) -> Result<(TimeStamp, SignalValue), SignalErrors> {
let Signal(signal_enum) = &self; let Signal(signal_enum) = &self;
let num_val = signal_enum let num_val = signal_enum.query_num_val_on_tmln(
.query_num_val_on_tmln( desired_time,
desired_time, &vcd.tmstmps_encoded_as_u8s,
&vcd.tmstmps_encoded_as_u8s, &vcd.all_signals,
&vcd.all_signals );
); let str_val = signal_enum.query_string_val_on_tmln(
let str_val = signal_enum desired_time,
.query_string_val_on_tmln( &vcd.tmstmps_encoded_as_u8s,
desired_time, &vcd.all_signals,
&vcd.tmstmps_encoded_as_u8s, );
&vcd.all_signals
);
// Both num and str will return the newest value that is closest to // Both num and str will return the newest value that is closest to
// the desired time. If both have valid values, select the most recent // the desired time. If both have valid values, select the most recent
@ -92,14 +101,13 @@ impl<'a> Signal<'a> {
(Ok((num_val, num_time)), Ok((str_val, str_time))) => { (Ok((num_val, num_time)), Ok((str_val, str_time))) => {
if num_time > str_time { if num_time > str_time {
Ok((num_time, SignalValue::BigUint(num_val))) Ok((num_time, SignalValue::BigUint(num_val)))
} } else {
else {
Ok((str_time, SignalValue::String(str_val))) Ok((str_time, SignalValue::String(str_val)))
} }
} }
(Ok((num_val, time)), Err(_)) => Ok((time, SignalValue::BigUint(num_val))), (Ok((num_val, time)), Err(_)) => Ok((time, SignalValue::BigUint(num_val))),
(Err(_), Ok((str_val, time))) => Ok((time, SignalValue::String(str_val))), (Err(_), Ok((str_val, time))) => Ok((time, SignalValue::String(str_val))),
(Err(e), _e) => Err(e) (Err(e), _e) => Err(e),
} }
} }
} }
@ -179,11 +187,11 @@ type SignalValNum = BigUint;
impl SignalEnum { impl SignalEnum {
pub fn name(&self) -> String { pub fn name(&self) -> String {
match self { match self {
SignalEnum::Data { name, ..} => name, SignalEnum::Data { name, .. } => name,
SignalEnum::Alias { name, .. } => name SignalEnum::Alias { name, .. } => name,
}.clone() }
.clone()
} }
} }
// helper functions ultimately used by Signal's query functions later on // helper functions ultimately used by Signal's query functions later on
@ -311,7 +319,7 @@ impl SignalEnum {
fn bits_required(&self) -> Option<u16> { fn bits_required(&self) -> Option<u16> {
match self { match self {
SignalEnum::Data {num_bits, ..} => num_bits.clone(), SignalEnum::Data { num_bits, .. } => num_bits.clone(),
// TODO: Follow aliases? // TODO: Follow aliases?
SignalEnum::Alias { .. } => None, SignalEnum::Alias { .. } => None,
} }
@ -337,7 +345,7 @@ impl SignalEnum {
Self::Alias { Self::Alias {
name: _, name: _,
signal_alias, signal_alias,
path: _ path: _,
} => { } => {
let SignalIdx(idx) = signal_alias; let SignalIdx(idx) = signal_alias;
*idx *idx
@ -350,20 +358,15 @@ impl SignalEnum {
// 2. the vector of indices into timeline where events occur // 2. the vector of indices into timeline where events occur
// for this signal // for this signal
// else we propagate Err(..). // else we propagate Err(..).
let (string_vals, lsb_indxs_of_string_tmstmp_vals_on_tmln) = let (string_vals, lsb_indxs_of_string_tmstmp_vals_on_tmln) = match &all_signals[signal_idx]
match &all_signals[signal_idx] { {
SignalEnum::Data { SignalEnum::Data {
ref string_vals, ref string_vals,
ref lsb_indxs_of_string_tmstmp_vals_on_tmln, ref lsb_indxs_of_string_tmstmp_vals_on_tmln,
.. ..
} => { } => Ok((string_vals, lsb_indxs_of_string_tmstmp_vals_on_tmln)),
Ok(( SignalEnum::Alias { .. } => Err(SignalErrors::PointsToAlias),
string_vals, }?;
lsb_indxs_of_string_tmstmp_vals_on_tmln,
))
}
SignalEnum::Alias { .. } => Err(SignalErrors::PointsToAlias),
}?;
// this signal should at least have some events, otherwise, trying to index into // this signal should at least have some events, otherwise, trying to index into
// an empty vector later on would fail // an empty vector later on would fail
if lsb_indxs_of_string_tmstmp_vals_on_tmln.is_empty() { if lsb_indxs_of_string_tmstmp_vals_on_tmln.is_empty() {