Struct FstExportData 

pub(crate) struct FstExportData {
    pub(crate) hierarchy: Arc<Hierarchy>,
    pub(crate) time_table: Arc<TimeTable>,
    pub(crate) root: FstExportNode,
    pub(crate) signals: AHashMap<SignalRef, Arc<Signal>>,
    pub(crate) version: String,
    pub(crate) date: String,
    pub(crate) timescale_exponent: i8,
    pub(crate) time_scale_divisor: u128,
    pub(crate) start_time: Time,
    pub(crate) end_time: Time,
}

A self-contained snapshot of everything needed to write a set of variables (and only the hierarchy needed to reach them) to an FST file.

Kept separate from WellenContainer so that the actual (potentially slow) file writing can be handed off to a background task without holding a borrow of it.

Fields

hierarchy: Arc<Hierarchy>

Full source hierarchy, needed to resolve scope/var metadata when writing.

time_table: Arc<TimeTable>

Full source time table; only entries referenced by the exported signals are used.

root: FstExportNode

Minimal scope tree containing only the exported variables.

signals: AHashMap<SignalRef, Arc<Signal>>

Only the signals that are actually referenced by root.

version: String

FST header version string, copied from the source hierarchy.

date: String

FST header date string, copied from the source hierarchy.

timescale_exponent: i8

Final FST timescale exponent: the source unit’s exponent plus the multiplier’s and time stamps’ folded-in digits.

time_scale_divisor: u128

10.pow(time_scale_shift), precomputed so scale_time doesn’t need to redo it for every time stamp. See common_power_of_ten.

start_time: Time

Scaled first time stamp of the source simulation, written into the FST header.

end_time: Time

The last time stamp of the source simulation, so the export can cover the same time span even if no exported signal changes at that point.

Implementations

impl FstExportData

pub(crate) fn write_to_file(&self, path: &Utf8Path) -> Result<()>

Writes the previously selected variables to an FST file at path.

fn write_fst_value_changes<W: Write + Seek>( &self, out: &mut FstBodyWriter<W>, signals: &[(FstSignalId, Arc<Signal>)], ) -> Result<()>

Merges the value changes of signals in time order and writes them to out, rescaling each time stamp with scale_time (see time_scale_divisor).