Struct dwfv::signaldb::SignalDB

pub struct SignalDB { /* fields omitted */ }

Signal Database

Example:

use dwfv::signaldb::{Signal, SignalDB, SignalValue, Timestamp};
let mut db = SignalDB::new();

Implementations

impl SignalDB

pub fn new() -> SignalDB

Create a new and empty SignalDB

Examples

use dwfv::signaldb::SignalDB;

let mut db = dwfv::signaldb::SignalDB::new();

pub fn from_vcd<I: BufRead>(input: I) -> Result<SignalDB, Box<dyn Error>>

Create a new SignalDB from a Value Change Dump (VCD) file.

Example

use dwfv::signaldb::{Scale, SignalDB, SignalValue, Timestamp};
let buf = std::io::Cursor::new("$scope module top $end
$var wire 32 0 foo $end
$var string 1 1 state $end
$var wire 1 2 bar $end
$upscope $end
$enddefinitions $end
#0
$dumpvars
b0 0
sINIT 1
$end
#1337
b101010 0
sTEST 1
");

let db = SignalDB::from_vcd(buf).unwrap();

let timestamp = Timestamp::new(1336, Scale::Picosecond);
assert_eq!(db.value_at("0", timestamp).unwrap(), SignalValue::new(0));
assert_eq!(db.value_at("1", timestamp).unwrap(), SignalValue::from_symbol_str("INIT"));

let timestamp = Timestamp::new(1338, Scale::Picosecond);
assert_eq!(db.value_at("0", timestamp).unwrap(), SignalValue::new(42));
assert_eq!(db.value_at("1", timestamp).unwrap(), SignalValue::from_symbol_str("TEST"));

pub fn from_vcd_with_limit<I: BufRead>(
    input: I,
    timestamp: Option<i64>
) -> Result<SignalDB, Box<dyn Error>>

Create a new SignalDB from a Value Change Dump (VCD) file and stop parsing the VCD file after reaching a given timestamp.

Example

use dwfv::signaldb::{Scale, SignalDB, SignalValue, Timestamp};
let buf = std::io::Cursor::new("$scope module top $end
$var wire 32 0 foo $end
$var string 1 1 state $end
$var wire 1 2 bar $end
$upscope $end
$enddefinitions $end
#0
$dumpvars
b0 0
sINIT 1
$end
#1337
b101010 0
sTEST 1
");

let db = SignalDB::from_vcd_with_limit(buf, Some(1300)).unwrap();

let timestamp = Timestamp::new(1000, Scale::Picosecond);
assert_eq!(db.value_at("0", timestamp).unwrap(), SignalValue::new(0));
assert_eq!(db.value_at("1", timestamp).unwrap(), SignalValue::from_symbol_str("INIT"));

let timestamp = Timestamp::new(1338, Scale::Picosecond);
assert_eq!(db.value_at("0", timestamp).unwrap(), SignalValue::new(0));
assert_eq!(db.value_at("1", timestamp).unwrap(), SignalValue::from_symbol_str("INIT"));

pub fn parse_vcd<I: BufRead>(&self, input: I) -> Result<(), Box<dyn Error>>

Extend the current SignalDB with the signals defined in a Value Capture Dump (VCD) file.

Example

use dwfv::signaldb::{Scale, SignalDB, SignalValue, Timestamp};
let buf = std::io::Cursor::new("$scope module top $end
$var wire 32 0 foo $end
$var string 1 1 state $end
$var wire 1 2 bar $end
$upscope $end
$enddefinitions $end
#0
$dumpvars
b0 0
sINIT 1
$end
#1337
b101010 0
sTEST 1
");

let mut db = SignalDB::new();
db.parse_vcd(buf).unwrap();

let timestamp = Timestamp::new(1336, Scale::Picosecond);
assert_eq!(db.value_at("0", timestamp).unwrap(), SignalValue::new(0));
assert_eq!(db.value_at("1", timestamp).unwrap(), SignalValue::from_symbol_str("INIT"));

let timestamp = Timestamp::new(1338, Scale::Picosecond);
assert_eq!(db.value_at("0", timestamp).unwrap(), SignalValue::new(42));
assert_eq!(db.value_at("1", timestamp).unwrap(), SignalValue::from_symbol_str("TEST"));

pub fn parse_vcd_with_limit<I: BufRead>(
    &self,
    input: I,
    timestamp: Option<i64>
) -> Result<(), Box<dyn Error>>

Extend the current SignalDB with the signals defined in a Value Change Dump (VCD) file and stop parsing the VCD file after reaching a given timestamp.

Example

use dwfv::signaldb::{Scale, SignalDB, SignalValue, Timestamp};
let buf = std::io::Cursor::new("$scope module top $end
$var wire 32 0 foo $end
$var string 1 1 state $end
$var wire 1 2 bar $end
$upscope $end
$enddefinitions $end
#0
$dumpvars
b0 0
sINIT 1
$end
#1337
b101010 0
sTEST 1
");

let mut db = SignalDB::new();
db.parse_vcd_with_limit(buf, Some(1300)).unwrap();

let timestamp = Timestamp::new(1000, Scale::Picosecond);
assert_eq!(db.value_at("0", timestamp).unwrap(), SignalValue::new(0));
assert_eq!(db.value_at("1", timestamp).unwrap(), SignalValue::from_symbol_str("INIT"));

let timestamp = Timestamp::new(1338, Scale::Picosecond);
assert_eq!(db.value_at("0", timestamp).unwrap(), SignalValue::new(0));
assert_eq!(db.value_at("1", timestamp).unwrap(), SignalValue::from_symbol_str("INIT"));

pub fn mark_as_initialized(&self)

Indicate that the SignalDB is initialized, meaning that no additional signals are expected to be added after that point.

Example

use dwfv::signaldb::SignalDB;

let mut db = SignalDB::new();

db.mark_as_initialized()

pub fn mark_as_invalid(&self)

Indicate that the content of the SignalDB may be invalid.

Example

use dwfv::signaldb::SignalDB;
let mut db = SignalDB::new();

assert_eq!(db.is_valid(), true);
db.mark_as_invalid();
assert_eq!(db.is_valid(), false);

pub fn is_valid(&self) -> bool

Check that the content of the SignalDB has not be been marked as invalid.

pub fn wait_until_initialized(&self) -> Result<(), InitializationError>

Wait until the SignalDB is marked as initialized and check that the content has not been invalidated.

Example

use dwfv::signaldb::SignalDB;
use std::sync::Arc;
use std::thread;

let db = Arc::new(SignalDB::new());
let db2 = db.clone();

thread::spawn(move|| {
    db2.mark_as_initialized()
});

db.wait_until_initialized();

pub fn set_status(&self, new_status: &str)

Set status message of the SignalDB.

Example

use dwfv::signaldb::SignalDB;
let mut db = SignalDB::new();

db.set_status("Hello, World!");
assert_eq!(db.get_status(), "Hello, World!");

pub fn get_status(&self) -> String

Get status message of the SignalDB

pub fn set_timescale(&self, scale: Timestamp)

Set default time scale of the SignalDB

pub fn get_timescale(&self) -> Timestamp

Get default time scale of the SignalDB

pub fn create_scope(&self, path: &[&str])

Create a scope in the SignalDB.

Example

use dwfv::signaldb::SignalDB;
let mut db = SignalDB::new();

db.create_scope(&vec!["foo", "bar"])

pub fn declare_signal(&self, scope: &[&str], signal: Signal)

Add a new signal in the SignalDB.

Example

use dwfv::signaldb::{Signal, SignalDB};
let mut db = SignalDB::new();

let scope = &vec!["foo", "bar"];
db.create_scope(&scope);

let signal = Signal::new("0", "baz", 32);
db.declare_signal(&scope, signal)

pub fn insert_event(
    &self,
    signal_id: &str,
    timestamp: Timestamp,
    new_value: SignalValue
) -> Result<(), SignalNotFound>

Insert an event in the specified signal.

Examples

use dwfv::signaldb::{Scale, Signal, SignalDB, SignalValue, Timestamp};
let mut db = SignalDB::new();

let scope = &vec!["foo", "bar"];
db.create_scope(&scope);

let signal = Signal::new("0", "baz", 32);
db.declare_signal(&scope, signal);

db.insert_event("0", Timestamp::new(42, Scale::Picosecond), SignalValue::new(0));

pub fn set_time(&self, timestamp: Timestamp)

Set the current time of the SignalDB

Example

use dwfv::signaldb::{Scale, Signal, SignalDB, SignalValue, Timestamp};
let mut db = SignalDB::new();
db.set_time(Timestamp::new(42, Scale::Picosecond));

pub fn set_current_value(
    &self,
    signal_id: &str,
    new_value: SignalValue
) -> Result<(), SignalNotFound>

Set the value of a signal at the current time.

Example

use dwfv::signaldb::{Scale, Signal, SignalDB, SignalValue, Timestamp};
let mut db = SignalDB::new();
db.set_time(Timestamp::new(42, Scale::Picosecond));
let scope = &vec!["foo", "bar"];
db.create_scope(&scope);

let signal = Signal::new("0", "baz", 32);
db.declare_signal(&scope, signal);

db.set_time(Timestamp::new(42, Scale::Picosecond));
db.set_current_value("0", SignalValue::new(0));

pub fn get_timestamps(&self) -> Vec<Timestamp>

Return all the timestamp where an event has been reported.

Example

use dwfv::signaldb::{Scale, Signal, SignalDB, SignalValue, Timestamp};
let mut db = SignalDB::new();

let scope = &vec!["foo", "bar"];
db.create_scope(&scope);

let signal = Signal::new("0", "baz", 32);
db.declare_signal(&scope, signal);
db.insert_event("0", Timestamp::new(42, Scale::Picosecond), SignalValue::new(0x1337));
db.insert_event("0", Timestamp::new(43, Scale::Picosecond), SignalValue::new(0x1338));
db.insert_event("0", Timestamp::new(44, Scale::Picosecond), SignalValue::new(0x1339));

let mut events = db.get_timestamps();
let values = vec![0, 42, 43, 44];

for (i, event) in events.iter().enumerate() {
    assert_eq!(*event, Timestamp::new(values[i], Scale::Picosecond));
}

pub fn value_at(
    &self,
    signal_id: &str,
    timestamp: Timestamp
) -> Result<SignalValue, SignalNotFound>

Return value of a signal at a given time.

Example

use dwfv::signaldb::{Scale, Signal, SignalDB, SignalValue, BitValue, Timestamp};
let mut db = SignalDB::new();

let scope = &vec!["foo", "bar"];
db.create_scope(&scope);

let signal = Signal::new("0", "baz", 32);
db.declare_signal(&scope, signal);
db.insert_event("0", Timestamp::new(42, Scale::Picosecond), SignalValue::new(0x1337));

assert_eq!(
    db.value_at("0", Timestamp::new(41, Scale::Picosecond)).unwrap(),
    SignalValue::new_default(32, BitValue::Undefined)
);
assert_eq!(
    db.value_at("0", Timestamp::new(42, Scale::Picosecond)).unwrap(),
    SignalValue::new(0x1337)
);
assert_eq!(
    db.value_at("0", Timestamp::new(43, Scale::Picosecond)).unwrap(),
    SignalValue::new(0x1337)
);

pub fn event_at(
    &self,
    signal_id: &str,
    timestamp: Timestamp
) -> Result<Option<SignalValue>, SignalNotFound>

Return event of a signal reported at a given time.

Example

use dwfv::signaldb::{Scale, Signal, SignalDB, SignalValue, BitValue, Timestamp};
let mut db = SignalDB::new();

let scope = &vec!["foo", "bar"];
db.create_scope(&scope);

let signal = Signal::new("0", "baz", 32);
db.declare_signal(&scope, signal);
db.insert_event("0", Timestamp::new(42, Scale::Picosecond), SignalValue::new(0x1337));

assert_eq!(
    db.event_at("0", Timestamp::new(41, Scale::Picosecond)).unwrap().is_none(),
    true
);
assert_eq!(
    db.event_at("0", Timestamp::new(42, Scale::Picosecond)).unwrap().unwrap(),
    SignalValue::new(0x1337)
);
assert_eq!(
    db.event_at("0", Timestamp::new(43, Scale::Picosecond)).unwrap().is_none(),
    true
);

pub fn get_signal_fullname(
    &self,
    signal_id: &str
) -> Result<String, SignalNotFound>

Get fullname of a signal.

Example

use dwfv::signaldb::{Scale, Signal, SignalDB, SignalValue, BitValue, Timestamp};
let mut db = SignalDB::new();

let scope = &vec!["foo", "bar"];
db.create_scope(&scope);

let signal = Signal::new("0", "baz", 32);
db.declare_signal(&scope, signal);

assert_eq!(db.get_signal_fullname("0").unwrap(), "foo.bar.baz[:32]");

pub fn signal_exists(&self, signal_id: &str) -> bool

Check that a signal exists in the SignalDB.

Example

use dwfv::signaldb::{Scale, Signal, SignalDB};
let mut db = SignalDB::new();

let scope = &vec!["foo", "bar"];
db.create_scope(&scope);

let signal = Signal::new("0", "baz", 32);
db.declare_signal(&scope, signal);

assert_eq!(db.signal_exists("0"), true);
assert_eq!(db.signal_exists("1"), false);

pub fn find_signals<F>(&self, f: F) -> Vec<String> where
    F: Fn(&Signal) -> bool, 

Search signals in the SignalDB that fulfill a given predicate.

Example

use dwfv::signaldb::{Scale, Signal, SignalDB};
let mut db = SignalDB::new();

let scope = &vec!["foo", "bar"];
db.create_scope(&scope);

let signal = Signal::new("0", "baz", 32);
db.declare_signal(&scope, signal);

assert_eq!(db.find_signals(|s| s.name == "baz"), vec!["0"]);
assert_eq!(db.find_signals(|s| s.name == "").len(), 0);

pub fn get_signal_ids(&self) -> Vec<String>

Return a vector of all the signal IDs registered in the SignalDB.

Example

use dwfv::signaldb::{Scale, Signal, SignalDB};
let mut db = SignalDB::new();

let scope = &vec!["foo", "bar"];
db.create_scope(&scope);

let signal = Signal::new("0", "baz", 32);
db.declare_signal(&scope, signal);

assert_eq!(db.get_signal_ids(), vec!["0"]);

pub fn get_next_rising_edge(
    &self,
    signal_id: &str,
    timestamp: Timestamp
) -> Result<Option<Timestamp>, SignalNotFound>

Get the timestamp of the next rising edge of a given signal.

Example

use dwfv::signaldb::{Scale, SignalDB, Timestamp};
let buf = std::io::Cursor::new("$scope module top $end
$var wire 1 0 foo $end
$upscope $end
$enddefinitions $end
#0
$dumpvars
b0 0
$end
#1337
10
#1338
00
");

let db = SignalDB::from_vcd(buf).unwrap();
assert_eq!(
    db.get_next_rising_edge("0", Timestamp::new(0, Scale::Picosecond)).unwrap().unwrap(),
    Timestamp::new(1337, Scale::Picosecond)
);
assert_eq!(
    db.get_next_rising_edge( "0", Timestamp::new(1338, Scale::Picosecond))
        .unwrap().is_none(),
    true
);
assert_eq!(
    db.get_previous_rising_edge("0", Timestamp::new(1338, Scale::Picosecond))
        .unwrap().unwrap(),
    Timestamp::new(1337, Scale::Picosecond)
);
assert_eq!(
    db.get_previous_rising_edge("0", Timestamp::new(2, Scale::Picosecond))
        .unwrap().is_none(),
    true
);

pub fn get_previous_rising_edge(
    &self,
    signal_id: &str,
    timestamp: Timestamp
) -> Result<Option<Timestamp>, SignalNotFound>

Get the timestamp of the previous rising edge of a given signal.

Example

See get_next_rising_edge.

pub fn get_next_falling_edge(
    &self,
    signal_id: &str,
    timestamp: Timestamp
) -> Result<Option<Timestamp>, SignalNotFound>

Get the timestamp of the next falling edge of a given signal.

Example

use dwfv::signaldb::{Scale, SignalDB, Timestamp};
let buf = std::io::Cursor::new("$scope module top $end
$var wire 1 0 foo $end
$upscope $end
$enddefinitions $end
#0
$dumpvars
b0 0
$end
#1337
10
#1338
00
");

let db = SignalDB::from_vcd(buf).unwrap();
assert_eq!(
    db.get_next_falling_edge("0", Timestamp::new(0, Scale::Picosecond)).unwrap().unwrap(),
    Timestamp::new(1338, Scale::Picosecond)
);

pub fn get_first_event(
    &self,
    signal_id: &str
) -> Result<Option<Timestamp>, SignalNotFound>

Get the timestamp of the first event of the signal.

Example

use dwfv::signaldb::{Scale, SignalDB, Timestamp};
let buf = std::io::Cursor::new("$scope module top $end
$var wire 1 0 foo $end
$upscope $end
$enddefinitions $end
#0
$dumpvars
b0 0
$end
#1337
10
#1338
00
");

let db = SignalDB::from_vcd(buf).unwrap();
assert_eq!(
    db.get_first_event("0").unwrap().unwrap(),
    Timestamp::new(0, Scale::Picosecond)
);
assert_eq!(
    db.get_last_event("0").unwrap().unwrap(),
    Timestamp::new(1338, Scale::Picosecond)
);

pub fn get_last_event(
    &self,
    signal_id: &str
) -> Result<Option<Timestamp>, SignalNotFound>

Get the timestamp of the last event of the signal.

Example

See get_first_event.

pub fn events_between(
    &self,
    signal_id: &str,
    begin: Timestamp,
    end: Timestamp
) -> Result<(SignalValue, usize, SignalValue), SignalNotFound>

Get an overview of the events of a signal during a given time period.

Example

use dwfv::signaldb::{Scale, SignalDB, SignalValue, Timestamp};
let buf = std::io::Cursor::new("$scope module top $end
$var wire 1 0 foo $end
$upscope $end
$enddefinitions $end
#0
$dumpvars
b0 0
$end
#1337
10
#1339
00
#1340
b101010 0
");

let db = SignalDB::from_vcd(buf).unwrap();
assert_eq!(
    db.events_between(
        "0", Timestamp::new(1, Scale::Picosecond),
        Timestamp::new(1340, Scale::Picosecond)).unwrap(),
    (SignalValue::new(0), 2, SignalValue::new(0))
);
assert_eq!(
    db.events_between("0", Timestamp::new(1, Scale::Picosecond),
        Timestamp::new(1339, Scale::Picosecond)).unwrap(),
    (SignalValue::new(0), 1, SignalValue::new(1))
);

pub fn search_all<'a>(
    &mut self,
    output: &mut dyn Write,
    expr: &'a str
) -> Result<(), Box<dyn Error>>

Search in the database and format the result in output.

Example

use dwfv::signaldb::SignalDB;
let vcd = std::io::Cursor::new("$scope module top $end
$var wire 1 0 foo $end
$upscope $end
$enddefinitions $end
#0
$dumpvars
b0 0
$end
#1337
10
#1338
00
");

let mut db = SignalDB::from_vcd(vcd).unwrap();
let mut buf = Vec::new();
db.search_all(&mut buf, "$0 = 1").expect("Invalid search expression");
assert_eq!(
    String::from_utf8(buf).unwrap(),
    "1337ps-1338ps\n"
);

let mut buf = Vec::new();
db.search_all(&mut buf, "$0 <- 1").expect("Invalid search expression");
assert_eq!(
    String::from_utf8(buf).unwrap(),
    "1337ps\n"
);

pub fn search<'a>(&self, expr: &'a str) -> Result<(), Box<dyn Error>>

Search in the SignalDB. The result of the search have to be retrieved with the functions defined below.

Example

use dwfv::signaldb::{Scale, FindingsSummary, SignalDB, Timestamp};
let vcd = std::io::Cursor::new("
$scope module logic $end
$var wire 1 # foo $end
$upscope $end
$enddefinitions $end
$dumpvars
b1 #
$end
#42
b0 #
#43
b1 #
#1337
b0 #
#1338
b1 #
");

let mut db = SignalDB::from_vcd(vcd).unwrap();

// Search expression
let expr = "$# = 0";

// Synchronous search
db.search(expr);

assert_eq!(
    db.get_first_finding(expr).unwrap().unwrap(),
    Timestamp::new(42, Scale::Picosecond)
);
assert_eq!(
    db.get_last_finding(expr).unwrap().unwrap(),
    Timestamp::new(1338, Scale::Picosecond)
);
assert_eq!(
    db.get_next_finding(expr, Timestamp::new(43, Scale::Picosecond)).unwrap().unwrap(),
    Timestamp::new(1337, Scale::Picosecond)
);
assert_eq!(
    db.get_end_of_next_finding(expr, Timestamp::new(43, Scale::Picosecond))
        .unwrap().unwrap(),
    Timestamp::new(1338, Scale::Picosecond)
);
assert_eq!(
    db.get_previous_finding(expr, Timestamp::new(43, Scale::Picosecond)).unwrap().unwrap(),
    Timestamp::new(42, Scale::Picosecond)
);
assert_eq!(
    db.findings_between(
        expr, Timestamp::new(0, Scale::Picosecond),
        Timestamp::new(1339, Scale::Picosecond)).unwrap(),
    FindingsSummary::Complex(2)
);

pub fn search_init<'a>(&self, expr: &'a str) -> Result<(), Box<dyn Error>>

Allocate a new search object in the SignalDB but don't perform actual search. This is meant to be used for asynchronous searches (see AsyncSignalDB)

pub fn search_at(
    &self,
    expr: &str,
    timestamp: Timestamp
) -> Result<(), Box<dyn Error>>

Check if an expression is valid at a given point of time. The expression must first be reported to the SignalDB using the search_init function. This is meant to be used for asynchronous searches (see AsyncSignalDB)

pub fn finish_search(&self, expr: &str) -> Result<(), Box<dyn Error>>

Indicate that a search object isn't active anymore. This is meant to be used for asynchronous searches (see AsyncSignalDB)

pub fn findings_between(
    &self,
    expr: &str,
    begin: Timestamp,
    end: Timestamp
) -> Result<FindingsSummary, SearchNotFound>

Get summary of findings within a time period.

Example

See search.

pub fn get_next_finding(
    &self,
    search_expr: &str,
    timestamp: Timestamp
) -> Result<Option<Timestamp>, SearchNotFound>

Get next finding of a given search expression.

Example

See search.

pub fn get_end_of_next_finding(
    &self,
    search_expr: &str,
    timestamp: Timestamp
) -> Result<Option<Timestamp>, SearchNotFound>

Get the timestamp where the search expression is not true anymore.

Example

See search.

pub fn get_previous_finding(
    &self,
    search_expr: &str,
    timestamp: Timestamp
) -> Result<Option<Timestamp>, SearchNotFound>

Get the previous finding of the given search expression.

Example

See search.

pub fn get_first_finding(
    &self,
    expr: &str
) -> Result<Option<Timestamp>, SearchNotFound>

Get the first finding of the given search expression.

Example

See search.

pub fn get_last_finding(
    &self,
    expr: &str
) -> Result<Option<Timestamp>, SearchNotFound>

Get the last finding of the given search expression.

Example

See search.

pub fn format_stats(&self, output: &mut dyn Write)

Format some stats of the SignalDB.

Example

use dwfv::signaldb::{Signal, SignalDB};
let mut db = SignalDB::new();

let scope = &vec!["foo", "bar"];
db.create_scope(&scope);

let signal = Signal::new("0", "baz", 32);
db.declare_signal(&scope, signal);

let mut buf = Vec::new();
db.format_stats(&mut buf);
assert_eq!(
    String::from_utf8(buf).unwrap(),
    "# foo\n#   bar\n#     0 (baz) - width: 32, edges: 0\n"
)

pub fn format_values_at(&self, output: &mut dyn Write, timestamp: i64)

Format the value of the signals at a given time.

Example

use dwfv::signaldb::{Scale, Signal, SignalDB, SignalValue, Timestamp};
let mut db = SignalDB::new();

let scope = &vec!["foo", "bar"];
db.create_scope(&scope);

let signal = Signal::new("0", "baz", 32);
db.declare_signal(&scope, signal);
db.insert_event("0", Timestamp::new(42, Scale::Picosecond), SignalValue::new(0x1337));

let mut buf = Vec::new();
db.format_values_at(&mut buf, 43);
assert_eq!(
    String::from_utf8(buf).unwrap(),
    "foo\n  bar\n    0 (baz) = h00001337\n"
)

Trait Implementations

impl Default for SignalDB

fn default() -> Self

Returns the "default value" for a type.