src/vcd/signal.rs

@@ -2,8 +2,8 @@
 // This program is distributed under both the GPLV3 license
 // and the YEHOWSHUA license, both of which can be found at
 // the root of the folder containing the sources for this program.
-use super::types::SignalIdx;
 use super::types;
+use super::types::SignalIdx;
 use num::BigUint;
 
 // Index to the least significant byte of a timestamp
@@ -39,11 +39,18 @@ impl<'a> Signal<'a> {
 
     pub fn path(&self) -> &[String] {
         match self.0 {
-            SignalEnum::Data {path, ..} => path,
+            SignalEnum::Data { 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> {
         let Signal(signal_enum) = &self;
         signal_enum.bits_required()
@@ -55,7 +62,9 @@ impl<'a> Signal<'a> {
         vcd: &types::VCD,
     ) -> Result<String, SignalErrors> {
         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(
         &self,
@@ -63,7 +72,9 @@ impl<'a> Signal<'a> {
         vcd: &types::VCD,
     ) -> Result<BigUint, SignalErrors> {
         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(
@@ -72,17 +83,15 @@ impl<'a> Signal<'a> {
         vcd: &types::VCD,
     ) -> Result<(TimeStamp, SignalValue), SignalErrors> {
         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,
             &vcd.tmstmps_encoded_as_u8s,
-                &vcd.all_signals
+            &vcd.all_signals,
         );
-        let str_val = signal_enum
+        let str_val = signal_enum.query_string_val_on_tmln(
-            .query_string_val_on_tmln(
             desired_time,
             &vcd.tmstmps_encoded_as_u8s,
-                &vcd.all_signals
+            &vcd.all_signals,
         );
 
         // Both num and str will return the newest value that is closest to
@@ -92,14 +101,13 @@ impl<'a> Signal<'a> {
             (Ok((num_val, num_time)), Ok((str_val, str_time))) => {
                 if num_time > str_time {
                     Ok((num_time, SignalValue::BigUint(num_val)))
-                }
+                } else {
-                else {
                     Ok((str_time, SignalValue::String(str_val)))
                 }
             }
             (Ok((num_val, time)), Err(_)) => Ok((time, SignalValue::BigUint(num_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 {
     pub fn name(&self) -> String {
         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
@@ -311,7 +319,7 @@ impl SignalEnum {
 
     fn bits_required(&self) -> Option<u16> {
         match self {
-            SignalEnum::Data {num_bits, ..} => num_bits.clone(),
+            SignalEnum::Data { num_bits, .. } => num_bits.clone(),
             // TODO: Follow aliases?
             SignalEnum::Alias { .. } => None,
         }
@@ -337,7 +345,7 @@ impl SignalEnum {
             Self::Alias {
                 name: _,
                 signal_alias,
-                path: _
+                path: _,
             } => {
                 let SignalIdx(idx) = signal_alias;
                 *idx
@@ -350,18 +358,13 @@ impl SignalEnum {
         // 2. the vector of indices into timeline where events occur
         //    for this signal
         // 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 {
                 ref string_vals,
                 ref lsb_indxs_of_string_tmstmp_vals_on_tmln,
                 ..
-                } => {
+            } => Ok((string_vals, lsb_indxs_of_string_tmstmp_vals_on_tmln)),
-                    Ok((
-                        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