Struct TimestampRecord 

pub struct TimestampRecord {
    pub val: PvString,
    pub oval: PvString,
    pub rval: i32,
    pub tst: i16,
    /* private fields */
}

Timestamp record — generates formatted timestamp strings.

Ported from EPICS std module timestampRecord.c.

Fields

val: PvString

Current formatted timestamp string (VAL).

oval: PvString

Previous value for change detection (OVAL).

rval: i32

Seconds past EPICS epoch (RVAL). DBF_ULONG in C; the Rust value model has no unsigned-32 scalar, so this follows the project convention of mapping DBF_ULONG to i32/EpicsValue::Long.

tst: i16

Timestamp format selector (TST), a DBF_MENU. Values 0..=10 select an explicit format; any other value is rendered with format 0 (C switch default: branch).

Trait Implementations

impl Default for TimestampRecord

fn default() -> Self

Returns the “default value” for a type.

impl Record for TimestampRecord

fn menu_field_choices(&self, field: &str) -> Option<&'static [&'static str]>

TST is DBF_MENU menu(timestampTST) (std timestampRecord.dbd); served as DBR_ENUM with the format-string choice labels.

fn set_process_context(&mut self, ctx: &ProcessContext)

C timestampRecord.c:90 reads ptimestamp->tse. The framework owns dbCommon.tse; this hook captures it so process() can take the device-time branch.

fn monitor_deadband_field(&self) -> &'static str

The timestamp record has NO value deadband: its monitored quantity is the formatted VAL string, and timestampRecord.dbd declares no MDEL/ADEL. C monitor() (timestampRecord.c:152-163) posts VAL (and RVAL) only inside if (strncmp(oval, val, sizeof(val))) — i.e. exactly when the formatted string changed since the previous process — then copies val into oval. That is plain change-detection, not a deadband.

The framework’s snapshot builders force-post the deadband field on every cycle the deadband gate fires (and the gate always fires for a non-numeric value — see [RecordInstance::check_deadband_ext], whose to_f64() returns None for a string VAL). Returning the default "VAL" here would therefore re-post VAL on every scan, even when the rendered string is unchanged — diverging from C’s strncmp gate. Returning "" (a name no field resolves to) suppresses that force-post (resolve_field("") is None, so the if let Some(val) = dval push is skipped) and routes VAL through the generic change-detection loop, which posts it only when it differs from the last posted value — matching C exactly. RVAL already change-detects through that same loop.

fn record_type(&self) -> &'static str

Return the record type name (e.g., “ai”, “ao”, “bi”).

fn process(&mut self) -> CaResult<ProcessOutcome>

Process the record (scan/compute cycle).

fn get_field(&self, name: &str) -> Option<EpicsValue>

Get a field value by name.

fn put_field(&mut self, name: &str, value: EpicsValue) -> CaResult<()>

Set a field value by name.

fn field_list(&self) -> &'static [FieldDesc]

Return the list of field descriptors.

fn clears_udf(&self) -> bool

Whether processing this record should clear UDF. Override to return false for record types that don’t produce a valid value every cycle.

fn took_metadata_change(&mut self) -> bool

Optional: report whether this record’s last process() call mutated a metadata-class field (EGU/PREC/HOPR/LOPR/HLM/LLM/ alarm limits / DRVH/DRVL / state strings).

fn field_metadata_override(&self, _field: &str) -> Option<FieldMetadataOverride>

Per-field override of the record-level display/control metadata for a GET / monitor snapshot of field.

fn long_string_fields(&self) -> &'static [&'static str]

Field names this record serves as a long string: a DBF_CHAR array field that semantically holds a NUL-terminated string.

fn process_passive_fields(&self) -> Option<&'static [&'static str]>

Field names declared pp(TRUE) in this record type’s DBD, or None if the type’s pp-flags have not been modeled.

fn validate_put(&self, _field: &str, _value: &EpicsValue) -> Result<(), CaError>

Validate a put before it is applied. Return Err to reject.

fn on_put(&mut self, _field: &str)

Hook called after a successful put_field.

fn primary_field(&self) -> &'static str

Primary field name (default “VAL”). Override for waveform etc.

fn val(&self) -> Option<EpicsValue>

Get the primary value.

fn set_val(&mut self, value: EpicsValue) -> Result<(), CaError>

Set the primary value.

fn accepts_raw_soft_input(&self) -> bool

Whether this record implements the DTYP="Raw Soft Channel" read path via Record::apply_raw_input. Records that return true opt into framework routing of the INP link value through apply_raw_input (RVAL + MASK) instead of the default soft-channel VAL direct write.

fn apply_raw_input(&mut self, value: EpicsValue) -> Result<(), CaError>

Apply a value read from a DTYP="Raw Soft Channel" INP link.

fn apply_invalid_output_value( &mut self, ivov: EpicsValue, ) -> Result<(), CaError>

Apply IVOA=2 (“set outputs to IVOV”) semantics: copy the IVOV value into whatever output staging field the OUT writeback consumes for this record type. Mirrors the per-record C recXxx.c behaviour:

fn can_device_write(&self) -> bool

Whether this record type supports device write (output records only). aao is included here even though it’s served by the same concrete struct as waveform/aai/subArray — the WaveformRecord’s can_device_write override picks the right answer per [ArrayKind], but this default matters for code that only has the record-type string.

fn is_put_complete(&self) -> bool

Whether async processing has completed and put_notify can respond. Records that return AsyncPendingNotify should return false while async work is in progress, and true when done. Default: true (synchronous records are always complete).

fn should_fire_forward_link(&self) -> bool

Whether this record should fire its forward link after processing.

fn should_output(&self) -> bool

Whether this record’s OUT link should be written after processing. Defaults to true. Override in calcout / longout to implement OOPT conditional output (epics-base 7.0.8).

fn on_output_complete(&mut self)

Notify the record that the OUT-link / device write completed successfully on this cycle. The framework calls this right after the actual write so transition-detection state (e.g. longout.pval) can update for the next cycle’s Self::should_output check. Default: no-op.

fn uses_monitor_deadband(&self) -> bool

Whether this record uses MDEL/ADEL deadband for monitor posting. Binary records (bi, bo, busy, mbbi, mbbo) return false because C EPICS always posts monitors for these record types regardless of whether the value changed.

fn monitor_value_changed(&self) -> Option<bool>

Per-record VALUE/LOG monitor gate for record types that post a monitor only when the value actually changed — and have no MDEL/ADEL deadband to express that.

fn monitor_always_post(&self) -> (bool, bool)

menuPost “Always” override for the VALUE / LOG monitor masks.

fn monitor_deadband_value(&self) -> Option<EpicsValue>

The value the MDEL/ADEL deadband is evaluated against.

fn alarm_cycle_monitored_fields(&self) -> &'static [&'static str]

Fields the record’s C monitor() posts on every cycle whose alarm transition fired, even when their value did not change.

fn force_posted_fields(&self) -> &'static [&'static str]

Fields the record’s C monitor() re-posts with DBE_VAL_LOG on every cycle that recomputed them, even when the value did not change — the analogue of an unconditional MARK(field) in C.

fn log_swept_fields(&self) -> &'static [&'static str]

Fields the record’s C monitor() re-posts with DBE_LOG ONLY on every cycle it names them, regardless of change — the analogue of an unconditional db_post_events(field, DBE_LOG) sweep.

fn init_record(&mut self, _pass: u8) -> Result<(), CaError>

Initialize record (pass 0: field defaults; pass 1: dependent init).

fn post_init_finalize_undef(&mut self, _udf: &mut bool) -> Result<(), CaError>

Post-init finalisation hook with mutable access to the framework’s UDF flag. Called once after both init_record passes complete. Default implementation is a no-op.

fn seed_deadband_tracking(&mut self)

Seed the monitor/archive/alarm deadband trackers (MLST/ALST/LALM) from the initial value at iocInit, called once by the builder after both init_record passes and post_init_finalize_undef.

fn set_resolved_input_links(&mut self, _resolved: &[&'static str])

Called by the framework immediately after applying this cycle’s Record::multi_input_links fetches, before process().

fn special(&mut self, _field: &str, _after: bool) -> Result<(), CaError>

Called before/after a field put for side-effect processing.

fn monitor_side_effect_fields( &self, _put_field: &str, ) -> &'static [&'static str]

Other fields whose monitors must be posted because a put to put_field changed them as a side effect, without driving a full process cycle.

fn as_any_mut(&mut self) -> Option<&mut (dyn Any + 'static)>

Downcast to concrete type for device support init injection. Override in record types that need device support to inject state (e.g., MotorRecord).

fn value_is_undefined(&self) -> bool

Whether the record’s current VAL is undefined (UDF must stay set).

fn check_alarms(&mut self, _common: &mut CommonFields)

Per-record alarm hook — evaluate record-type-specific alarms (STATE / COS / analog limit / SOFT) and accumulate them into nsta/nsev via recGblSetSevr.

fn multi_input_links(&self) -> &[(&'static str, &'static str)]

Return multi-input link field pairs: (link_field, value_field). Override in calc, calcout, sel, sub to return INPA..INPL → A..L mappings.

fn multi_output_links(&self) -> &[(&'static str, &'static str)]

Return multi-output link field pairs: (link_field, value_field). Override in transform to return OUTA..OUTP → A..P mappings.

fn put_field_internal( &mut self, name: &str, value: EpicsValue, ) -> Result<(), CaError>

Internal field write that bypasses read-only checks. Used by the framework to write values from ReadDbLink actions into fields that are normally read-only (e.g., epid.CVAL). Default implementation delegates to put_field().

fn pre_process_actions(&mut self) -> Vec<ProcessAction>

Return pre-process actions (ReadDbLink) that the framework should execute BEFORE calling process(). This is called once per cycle. Default returns empty. Override in records that need link reads to be available during process().

fn pre_input_link_actions(&mut self) -> Vec<ProcessAction>

Return actions the framework must execute BEFORE the input-link (multi_input_links, INP -> value-field) fetch for this cycle.

fn set_async_context(&mut self, _name: String, _db: AsyncDbHandle)

Called once by the framework when the record is registered (add_record), delivering the record its own canonical name plus a cycle-free crate::server::database::AsyncDbHandle for driving async-side updates from OUTSIDE a process() cycle.

fn init_links(&mut self, _common: &CommonFields)

Framework init hook: called once at record load after the common link fields (INP/OUT/FLNK/…) have been resolved and the init_record passes have run, with the record’s resolved CommonFields.

fn set_device_did_compute(&mut self, _did_compute: bool)

Called by the framework before process() to indicate whether device support’s read() already performed the record’s compute step. Override in records that have a built-in compute (e.g., epid PID) to skip it when device support already ran it. Default: ignore.

fn soft_channel_skips_convert(&self) -> bool

Whether this record has a raw-to-engineering (RVAL → VAL) convert() step that must be skipped on a Soft Channel input.