Struct ThrottleRecord 

pub struct ThrottleRecord {

    pub val: f64,
    pub oval: f64,
    pub sent: f64,
    pub osent: f64,
    pub wait: i16,
    pub hopr: f64,
    pub lopr: f64,
    pub drvlh: f64,
    pub drvll: f64,
    pub drvls: i16,
    pub drvlc: i16,
    pub ver: String,
    pub sts: i16,
    pub prec: i16,
    pub dprec: i16,
    pub dly: f64,
    pub out: String,
    pub ov: i16,
    pub sinp: String,
    pub siv: i16,
    pub sync: i16,
    /* private fields */
}

Throttle record — rate-limits value changes to prevent device damage.

Ported from EPICS std module throttleRecord.c.

When VAL is written, the record checks drive limits, optionally clips the value, sets WAIT=True, then writes SENT to the OUT link only after the minimum delay (DLY) has elapsed since the last output. If a new value arrives during the delay, it queues the latest value and sends it when the delay expires.

Fields

val: f64

Set value (VAL)

oval: f64

Previous set value (OVAL), read-only

sent: f64

Last sent value (SENT), read-only

osent: f64

Previous sent value (OSENT), read-only

wait: i16

Busy flag (WAIT): 0=False, 1=True, read-only

hopr: f64

High operating range (HOPR)

lopr: f64

Low operating range (LOPR)

drvlh: f64

High drive limit (DRVLH)

drvll: f64

Low drive limit (DRVLL)

drvls: i16

Limit status: 0=Normal, 1=Low, 2=High (DRVLS), read-only

drvlc: i16

Limit clipping: 0=Off, 1=On (DRVLC)

ver: String

Code version string (VER), read-only

sts: i16

Record status: 0=Unknown, 1=Error, 2=Success (STS), read-only

prec: i16

Display precision (PREC)

dprec: i16

Delay display precision (DPREC)

dly: f64

Delay between outputs in seconds (DLY)

out: String

Output link (OUT)

ov: i16

Output link valid: 0=ExtNC, 1=Ext, 2=Local, 3=Constant (OV), read-only

sinp: String

Sync input link (SINP)

siv: i16

Sync input link valid (SIV), read-only

sync: i16

Sync trigger: 0=Idle, 1=Process (SYNC)

Trait Implementations

impl Default for ThrottleRecord

fn default() -> Self

Returns the “default value” for a type.

impl Record for ThrottleRecord

fn should_fire_forward_link(&self) -> bool

C throttleRecord.c:308 keeps recGblFwdLink(prec) commented out in process() — the forward link is fired ONLY from valuePut’s non-CONSTANT branch (throttleRecord.c:580), i.e. only on a cycle where a real OUT write actually occurred. The framework default fires FLNK every process(), which would also fire it on a queuing-during-delay cycle, a rejected out-of-range cycle, a drain with nothing queued, and a CONSTANT-OUT cycle — none of which write OUT in C. process() maintains out_written (reset to false each cycle, set true only by send_value on a real OUT write); this hook returns it.

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 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 special(&mut self, field: &str, after: bool) -> CaResult<()>

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

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 init_record(&mut self, pass: u8) -> CaResult<()>

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

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 put_field_internal(&mut self, name: &str, value: EpicsValue) -> CaResult<()>

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 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 analogue of [Record::apply_raw_input]. 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 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_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_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 monitor_deadband_field(&self) -> &'static str

The FIELD whose VALUE/LOG monitor delivery the MDEL/ADEL deadband gates — the field Self::monitor_deadband_value reads. A record overriding one must override both consistently.

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

Secondary value fields a record posts with the primary VAL monitor mask, from INSIDE the same guard C wraps its VAL post in — never with a forced DBE_VALUE | DBE_LOG on every change.

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_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 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(&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 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 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 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_process_context(&mut self, _ctx: &ProcessContext)

Called by the framework immediately before process() to push a read-only snapshot of framework-owned [CommonFields] state (ProcessContext) that the record’s process() needs to see.

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.