Struct TimestampRecord 

pub struct TimestampRecord {
    pub val: PvString,
    pub oval: PvString,
    pub rval: u32,
    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: u32

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. field(RVAL,DBF_ULONG) (timestampRecord.dbd:28) — C ptimestamp->rval = ptimestamp->time.secPastEpoch (timestampRecord.c:94), and secPastEpoch is an epicsUInt32. Stored i32 and served EpicsValue::Long while the port hand-wrote its own field table.

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 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.

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

C monitor()’s single gate: the strncmp(oval, val) string change (timestampRecord.c:158). Reported here so the framework’s VAL monitor mask is live only on a cycle that re-rendered a different string — which is also the gate RVAL hangs off (see Self::fields_posted_with_value_mask).

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

C posts RVAL from inside the VAL-string-change guard, with VAL’s own monitor mask and with no test of RVAL’s own value (db_post_events(&ptimestamp->rval, monitor_mask), timestampRecord.c:160) — so the seconds count reaches monitors exactly when the rendered string moves, and no more often.

Left to the generic change-detection loop instead, RVAL posts on every process that crosses a second — ~59 spurious DBE_VALUE|DBE_LOG events a minute per subscriber under a coarse TST such as HH:MM, whose VAL only changes once a minute.

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 declared_fields(&self) -> &'static [FieldDesc]

The field declaration of a record type base’s .dbd set does not cover — a record type that lives in another crate.

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 implements_field(&self, name: &str) -> bool

Does this record type implement name in its own get_field / put_field, as opposed to leaving it to the framework’s dbCommon handling?

fn field_no_mod(&self, _field: &str) -> bool

SPC_NOMOD that a record’s cvt_dbaddr decides at runtime, from record state — the dynamic half of the no-modify declaration.

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

Choice strings for a record-specific DBF_MENU field served as DBR_ENUM, keyed by field name (uppercase, as declared).

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 property_support(&self) -> PropertySupport

Which of C’s six nullable rset get_* property slots THIS record type implements — the record’s own #define get_xxx NULL lines.

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) -> &'static [&'static str]

Field names declared pp(TRUE) in this record type’s DBD (empty if none, e.g. event/histogram, or if the type is unmodeled).

fn processes_after_put(&self, field: &str) -> bool

Whether a put to field should reprocess this Passive record.

fn enum_state_strings(&self) -> Option<Vec<PvString>>

The record’s DBF_ENUM state strings — the C rset slot pair get_enum_strs / put_enum_str, which in C read the same fields and are therefore ONE table here.

fn enum_string_form(&self) -> Option<EnumStringForm>

The record’s get_enum_str rset slot — how a DBR_STRING READ of its DBF_ENUM VAL renders. A THIRD slot, distinct from the pair above: C’s get_enum_str (singular) is not get_enum_strs (plural), and serving the read from the plural table is what made an undefined mbbi state come out as its index.

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 is_subroutine_name_field(&self, _field: &str) -> bool

Whether a put to field names a subroutine that must resolve in the function registry — C special(SPC_MOD) → registryFunctionFind (aSubRecord.c::special, subRecord.c::special). C stores the name in dbPut, then special(after) looks it up and returns S_db_BadSub (→ rsrv ECA_PUTFAIL) when the name is non-empty and unregistered, so the client’s write is REFUSED while the field keeps the value it was given. An empty name names no routine and is accepted.

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

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

fn is_udf_defining_put(&self, field: &str) -> bool

Whether a put to field directly defines the record — clears UDF exactly like a primary-value-field put. C dbAccess.c::dbPut (:1409-1411) clears udf synchronously only when the put target is dbIsValueField (i.e. field == primary_field()); this hook is where a record type says its own special() ALSO clears UDF for a non-value field, independent of dbIsValueField.

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

Get the primary value.

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

Set the primary value.

fn input_read_by_device_support(&self) -> bool

Whether this record’s INP is read by DEVICE SUPPORT (a C DSET), as opposed to by the record body itself.

fn soft_input_dset_init(&mut self, loaded: bool)

The rest of the soft INPUT device support’s init_record, once the constant-INP load above has (or has not) landed.

fn raw_soft_input( &mut self, entry: RawSoftEntry, value: EpicsValue, ) -> Option<Result<(), CaError>>

The DTYP="Raw Soft Channel" INPUT dset — C’s four devXxxSoftRaw.c read supports (devAiSoftRaw, devBiSoftRaw, devMbbiSoftRaw, devMbbiDirectSoftRaw).

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

The DTYP="Raw Soft Channel" OUTPUT dset — C’s four devXxxSoftRaw.c write supports: the value write_xxx() puts to the OUT link.

fn apply_raw_readback(&mut self, _raw: i32) -> bool

Apply a raw device value read back from an output record’s device support (the asyn init seed and driver readback callback), the output counterpart of an input record’s raw path, where device support writes RVAL and the record’s own conversion produces VAL (device_support.rs:43-46). An output record whose convert() is forward (engineering → raw) must invert it here — store the raw value into RVAL and compute the engineering VAL — because the framework’s forward convert would otherwise recompute RVAL from the stale VAL and discard the readback (C processAo/initAo set rval/val directly, devAsynInt32.c:955-957/:973-994).

fn apply_float64_readback(&mut self, _raw: f64) -> bool

Apply a float64 device value read back from an output record’s asyn device support — the asynFloat64 analogue of Record::apply_raw_readback. A float64 output (ao) whose device value carries an ASLO/AOFF linear scaling must seed the engineering VAL here (VAL = value * ASLO + AOFF), because the asyn store path would otherwise write the raw device value straight into VAL and drop the scaling. Sets VAL only (a float64 ao carries no RVAL); the reverse scaling (OVAL - AOFF) / ASLO is applied on the device-write side. Mirrors C initAo/processAo (devAsynFloat64.c:627-629/:646-649).

fn install_breaktable_registry(&mut self, _registry: Arc<BreakTableRegistry>)

Hand the record the database’s breakpoint-table registry so an ai/ao with LINR >= 3 can resolve and cache the table its LINR selects. Called once at iocInit, before the first process/convert. The record resolves the table lazily on the first conversion (and re-resolves when LINR changes at runtime), mirroring C cvtRawToEngBpt’s init || *ppbrk == NULL cache. The default is a no-op: only ai/ao carry LINR.

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 crate::server::records::waveform::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 restamps_time_after_completion(&self) -> bool

C parity: a record whose completion restamps TIME AFTER the VAL monitor post and the forward link, not before the value post like every standard record (aoRecord.c:190 stamps ahead of writeValue).

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 process_posts_value_monitor(&self) -> bool

Whether this record’s process cycle posts its primary value (VAL) as a value monitor (DBE_VALUE / DBE_LOG).

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 take_cycle_posted_fields(&mut self) -> Vec<(&'static str, CyclePostMask)>

Fields this cycle’s C monitor() posted UNCONDITIONALLY, chosen per cycle from record state — the DYNAMIC sibling of Self::force_posted_fields.

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

Fields whose ONLY post path is the record’s own per-cycle mark — C never change-detects them, so a value change alone must post nothing.

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 value_only_change_fields(&self) -> &'static [&'static str]

Fields whose change-detected monitor post must carry DBE_VALUE only — the LOG bit is stripped — instead of the framework default DBE_VALUE | DBE_LOG.

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

Change-detected auxiliary fields this record posts with C’s monitor_mask | DBE_VALUE — VAL’s monitor mask ORed with DBE_VALUE, and NOT the framework default monitor_mask | DBE_VALUE | DBE_LOG.

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

Fields whose change post carries a LITERAL DBE_VALUE | DBE_LOG — this cycle’s alarm bits DISCARDED.

fn array_monitor_post(&mut self) -> Option<ArrayMonitorPost>

The array-style monitor decision (C waveform/aai/aao monitor(), waveformRecord.c:291-326). None (the default) means the record has no MPST/APST/HASH mechanism and the generic MDEL/ADEL deadband decision applies. Some(_) lets the record replace that with its “Always vs On Change” rule: it hashes the array content, compares to the stored HASH, updates it, and reports whether DBE_VALUE / DBE_LOG should be on the VAL post this cycle and whether the hash changed (so the owner posts HASH with DBE_VALUE). Called by check_deadband_ext (the single owner of the VAL-mask decision).

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

Fields the record posts itself via an event-driven, individually masked path rather than the generic change-detection loop. The framework excludes these from that loop so they are neither double-posted nor spuriously posted on a cycle the event did not fire. C waveform/aai/aao monitor() posts HASH this way — db_post_events(prec, &prec->hash, DBE_VALUE) only when the content hash changed (waveformRecord.c:317-319), never via VAL’s change.

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

Fields the record posts itself via an event-driven, individually masked path rather than the generic change-detection loop. The framework excludes these from that loop so they are neither double-posted nor spuriously posted on a cycle the event did not fire. C waveform/aai/aao monitor() posts HASH this way — db_post_events(prec, &prec->hash, DBE_VALUE) only when the content hash changed (waveformRecord.c:317-319), never via VAL’s change.

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

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

fn init_record_parks_pact(&self) -> bool

Did init_record leave the record PERMANENTLY ACTIVE — C’s prec->pact = TRUE inside init_record, which is how a record type disables itself when it cannot possibly process?

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 init_resets_alarms(&self) -> bool

Whether this record type’s C init_record resets the record to a defined, no-alarm state — prec->udf = 0; recGblResetAlarms(prec) — so a freshly loaded, never-processed record reads UDF=0, STAT=NO_ALARM, SEVR=NO_ALARM instead of the born UDF/INVALID/1.

fn field_native_count(&self, _field: &str) -> Option<u32>

The channel’s native (maximum) element count for field, when it differs from the count of the field’s current value.

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 set_fetch_gate_failed(&mut self, _failed: bool)

Report this cycle’s fetch_values() outcome: failed == true means C’s helper would have returned a non-zero status, so the record body — the calcPerform / do_sel the C process() wraps in if (fetch_values(prec) == 0) — must NOT run, and VAL/UDF freeze.

fn set_subroutine_status(&mut self, _status: i64)

Report this cycle’s subroutine status — C process’s status variable for sub/aSub:

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

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

fn watchdog_interval(&self) -> Option<Duration>

The period of this record’s monitor watchdog, or None when it has none — C histogramRecord.c::wdogInit (:126-152):

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

One watchdog tick — C histogramRecord.c::wdogCallback (:102-124):

fn uses_recgbl_simm_helpers(&self) -> bool

Whether this record type’s support reads SIML through the recGbl simulation helpers (recGblGetSimm/recGblInitSimm, and therefore recGblSaveSimm/recGblCheckSimm) rather than a bare dbGetLink.

fn aborts_on_failed_siml_read(&self) -> bool

The record’s readValue/writeValue ABORTS when the SIML read fails — it returns before performing any I/O, so the cycle does no device write, no SIOL redirect, and raises no SIMM_ALARM.

fn set_io_intr_scan(&mut self, _active: bool)

The record joined (true) or left (false) the SCAN="I/O Intr" list.

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

The link writes a C special() performs itself, inside dbPut.

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 special_commits_alarms(&self, _put_field: &str) -> bool

True iff the C special() for a put to put_field runs the record’s own monitor() — whose first act is recGblResetAlarms(prec), which commits nsta/nsev into stat/sevr and clears the born-UDF alarm.

fn special_checks_alarms(&self, _put_field: &str) -> bool

True iff the C special() for a put to put_field runs code that writes stat/sevr DIRECTLY (not nsta/nsev) with NO monitor() / recGblResetAlarms after it — so the write STICKS and a later caget observes it, unlike the process path where recGblResetAlarms erases it.

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 clears_udf_unconditionally(&self) -> bool

Whether this record’s C process() clears UDF regardless of the read’s status — i.e. even when readValue failed.

fn declares_inp_link(&self) -> bool

Whether this record type’s .dbd declares an INP field at all.

fn read_constant_inp(&mut self, _value: Option<EpicsValue>) -> bool

Process-time INP read when the INP link is CONSTANT (or unset) — the per-record exception to the load-once rule.

fn raises_udf_alarm(&self) -> bool

Whether this record type raises UDF_ALARM at all.

fn udf_alarm_on_exact_one(&self) -> bool

Whether this record’s C checkAlarms tests the UDF byte with if (prec->udf == TRUE) (EXACT-ONE) rather than if (prec->udf) (truthy). See crate::server::recgbl::udf_alarm_active: exact-one records (boRecord.c:371, stringoutRecord.c:146, biRecord.c:225, busyRecord.c:337) do NOT raise UDF_ALARM for a udf byte that is neither 0 nor 1.

fn udf_alarm_message(&self) -> &str

The alarm message C attaches when raising UDF_ALARM.

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 special_reseed_input_links(&self) -> &[(&'static str, &'static str)]

The (link_field, value_field) pairs whose CONSTANT value this record’s C special() RE-SEEDS on a runtime put to the link field — recGblInitConstantLink(plink, DBF_DOUBLE, pvalue) + db_post_events(prec, pvalue, DBE_VALUE) + INAV = CON (calcoutRecord.c:367-378, sCalcoutRecord.c:512-517, aCalcoutRecord.c:534-540).

fn special_reseed_post_mask(&self) -> EventMask

The event mask of the db_post_events call in that record’s special() re-seed arm — the C call sites do not agree:

fn constant_init_links(&self) -> Vec<ConstantInitLink>

Every CONSTANT input link this record seeds ONCE, at init_record — the record’s own recGblInitConstantLink / dbLoadLinkArray table, transcribed from its C.

fn constant_ls_link(&self) -> Option<&'static str>

The link field this record loads into its long-string VAL at init through C’s dbLoadLinkLS — "DOL" for lso (lsoRecord.c:82), "INP" for lsi (its soft device support, devLsiSoft.c:24). loadLS is a lset entry of its own, so this is a SEPARATE table from Self::constant_init_links, not a variant of it; the same init-seed owner runs both.

fn apply_ls_load(&mut self, _load: LsLoad) -> u32

Apply the Self::constant_ls_link load, and return the resulting LEN. The record clamps the text at its own SIZV and runs C’s init tail (if (prec->len) { strcpy(prec->oval, prec->val); prec->olen = prec->len; }, lsoRecord.c:92-95 / lsiRecord.c:85-88); the owner turns a non-zero LEN into udf = FALSE.

fn constant_inputs_deliver_at_process(&self) -> bool

Whether this record’s CONSTANT input links deliver their value on EVERY process cycle instead of only at init.

fn select_input_links( &self, _selector: Option<u16>, ) -> Option<Vec<(&'static str, &'static str)>>

The subset of Self::multi_input_links the framework should actually fetch this cycle, given an optional externally-resolved selector index (sel’s NVL→SELN value, or None when no NVL link drove it). Default None = fetch every input link.

fn simulation_substitutes_input_stage(&self) -> bool

A SIMM != NO cycle substitutes only this record’s INPUT STAGE — the rest of its process() still runs.

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

Land the scalar a simulated cycle read from SIOL (through SVAL, where the record has one) — C readValue’s assignment plus whatever the record’s process() body then does with it, under the same status == 0 gate the framework applies before calling this.

fn rejects_illegal_sim_mode(&self) -> bool

Whether the record’s C switch (prec->simm) carries a default: arm that REFUSES a SIMM value outside its own menu:

fn set_simulation_active(&mut self, _active: bool)

This cycle’s simulation state, pushed by the framework before process() — the twin of Self::set_fetch_gate_failed, and only for a record that declares Self::simulation_substitutes_input_stage.

fn input_fetch_policy(&self) -> InputFetchPolicy

How C’s fetch_values() for this record type reacts to a link read that fails. Drives the framework’s Self::multi_input_links fetch loop; see InputFetchPolicy. Default: InputFetchPolicy::ReadAll.

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

String-valued input links: (link_field, value_field) pairs read as DBR_STRING, C sCalcoutRecord.c::fetch_values (890-941) — the SECOND loop of that function, over INAA..INLL → AA..LL:

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

Input links this record reads at OUTPUT time instead of during the input-fetch phase: (link_name_field, value_field) pairs. The framework reads each configured link immediately before the OUT write, and ONLY on a cycle where the output actually fires (Self::should_output and no IVOA veto), then writes the value into value_field via Self::put_field; a failed read leaves the field alone.

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

The value the framework writes to the OUT link. The single owner of “what goes out”, shared by the soft-OUT write, the async-completion write and the simulated SIOL redirect.

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 multi_output_buffer( &self, link_field: &str, staged: EpicsValue, target: &OutTarget, ) -> EpicsValue

The record’s C soft device support write-buffer switch for a multi-output pair: given the pair’s staged value (the value field named by Self::multi_output_links) and the RESOLVED TARGET metadata, return the buffer C would actually put.

fn typed_output_buffer( &self, link_field: &str, target: &OutTarget, ) -> Option<EpicsValue>

The buffer to put on an OUT link the record drives itself, chosen from the RESOLVED TARGET — the no-staged-value sibling of Self::multi_output_buffer.

fn set_resolved_out_target(&mut self, link_field: &str, target: OutTarget)

Receive the RESOLVED target of an OUT link the record asked to have resolved before this cycle’s process() (ProcessAction::ResolveOutTarget).

fn input_link_read_as( &self, link_field: &str, source: &OutTarget, ) -> Option<LinkReadAs>

The dbrType this record’s ProcessAction::ReadDbLink on link_field asks the SOURCE for — the READ twin of Self::typed_output_buffer, and C’s dbGetLink second argument.

fn output_event(&self) -> Option<String>

Return the name of the output event (OEVT) to post this cycle, or None. The event-subsystem twin of the OUT write: a downstream SCAN="Event" / EVNT="<name>" record is woken each time the record drives output. Mirrors C calcout/sCalcout/aCalcout execOutput, which calls postEvent(epvt) / post_event(oevt) immediately after writeValue in every OUT-driving branch.

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.

fn skips_forward_convert_when_undefined(&self) -> bool

Whether this output record’s forward VAL → RVAL convert() must be SKIPPED on a process cycle where VAL is still undefined (UDF != 0) and no value source ran.

fn skips_timestamp_when_undefined(&self) -> bool

C mbboRecord.c:210-221 / mbboDirectRecord.c:190-202 — the same else if (prec->udf) goto CONTINUE that skips the forward convert() ALSO jumps past the pre-output recGblGetTimeStampSimm call. So a soft (synchronous) mbbo/mbboDirect that is still UNDEFINED never stamps TIME on the first-pass output stage: the only other stamp after CONTINUE: is guarded by if (pact) (mbboRecord.c:256-258), which fires on ASYNCHRONOUS completion re-entry only. A sync UDF record therefore keeps TIME at the EPICS epoch (“never processed”) until a VAL put clears UDF.