Enum ProcessAction 

pub enum ProcessAction {
    WriteDbLink {
        link_field: &'static str,
        value: EpicsValue,
    },
    ResolveOutTarget {
        link_field: &'static str,
    },
    ReadDbLink {
        link_field: &'static str,
        target_field: &'static str,
    },
    ReprocessAfter(Duration),
    ScanOnce,
    DeviceCommand {
        command: &'static str,
        args: Vec<EpicsValue>,
    },
    WriteDbLinkNotify {
        link_field: &'static str,
        value: EpicsValue,
    },
    ArmWatchdog,
    CancelReprocess,
}

Side-effect actions that a record requests from the processing framework.

Records return these from process() via ProcessOutcome::actions. The framework executes them at the appropriate point in the processing cycle, keeping records as pure state machines without direct DB access.

Variants

WriteDbLink

Write a value to a DB link. The framework reads link_field from the record to get the target PV name, then writes value to that PV.

Executed after alarm/snapshot, before FLNK. Example: scaler writes CNT to COUT/COUTP links.

Fields

link_field: &'static str

value: EpicsValue

ResolveOutTarget

Resolve an OUT link’s TARGET (OutTarget) and hand it to the record through Record::set_resolved_out_target, BEFORE process() runs.

Pre-process action — the OUT-link twin of Self::ReadDbLink, and C’s checkLinks-cached lnk_field_type: a record whose fire-time branch depends on the target’s DBF class (sseq decides the wire buffer AND whether a WAITn put-callback is issued from the one switch, sseqRecord.c:714-792) must have the class in hand when it decides, not after the framework’s put path has already been entered.

Fields

link_field: &'static str

ReadDbLink

Read a value from a DB link into a record field. The framework reads link_field from the record to get the source PV name, reads that PV, and writes the result into target_field via an internal put that bypasses read-only checks.

The value delivered is the link target’s native EpicsValue — it is NOT coerced to a numeric type on the way in. The record coerces (or preserves) it at its own put_field/put_field_internal boundary, so a string-class source can reach a string field byte-exact (the sseq DOLn→STRn path, C sseqRecord.c:643-705). Records whose target_field is numeric simply convert there, exactly as before.

Pre-process action: executed BEFORE the next process() cycle so the value is immediately available. This matches C EPICS dbGetLink() which is synchronous/immediate.

Example: throttle reads SINP into VAL when SYNC is triggered.

Fields

link_field: &'static str

target_field: &'static str

ReprocessAfter(Duration)

Schedule a re-process of this record after the given duration. The framework spawns tokio::spawn(sleep(d) + process_record(name)). The current cycle’s OUT/FLNK/notify proceed normally.

Equivalent to C EPICS callbackRequestDelayed() + scanOnce().

ScanOnce

C scanOnce(precord) — queue ONE process of this record, now.

A record’s special() emits this when a put changed state the record must act on but the put itself will not process the record. C guards every such call with if (precord->scan) — scaler special() (scalerRecord.c:655 CNT, :667 CONT), whose comment is exactly the contract: “Scan record if it’s not Passive. (If it’s Passive, it’ll get scanned automatically, since .cnt is a Process-Passive field.)”

The FRAMEWORK owns that gate, not the record: the framework owns SCAN and owns the pp(TRUE) reprocess decision (dbPutField, dbAccess.c:1265-1268), and a record’s special() cannot see either. So a record emits ScanOnce unconditionally wherever C calls scanOnce, and the executor drops it for a Passive record — where the put’s own process already covers it and a second one would double-process.

Queued, not inline: C’s scanOnce hands the record to the scan-once thread, which takes dbScanLock — so the process lands after the putting thread leaves dbPutField.

DeviceCommand

Send a named command to the device support driver. The framework calls DeviceSupport::handle_command() with this data. Used by scaler to request reset/arm/write_preset operations without the record holding a direct driver reference.

Fields

command: &'static str

args: Vec<EpicsValue>

WriteDbLinkNotify

Write a value to a DB link as a put-with-completion, then re-enter THIS record’s process() when the downstream operation completes.

The framework arms a put-notify wait-set (C dbProcessNotify), writes link_field’s target through it, releases the initiator’s own count, and wires the completion to an async re-entry of this record (mint_async_token + reprocess_on_notify). The record returns RecordProcessResult::AsyncPending alongside this action and is re-entered once the downstream record (and its FLNK/OUT chain) finishes — the synApps sseq WAITn “wait for the put callback” dependency (sseqRecord.c::processNextLink, dbCaPutLinkCallback). Built on the same new_put_notify + reprocess_on_notify primitive an out-of-band crate::server::database::AsyncDbHandle caller uses.

Executed before FLNK, like Self::WriteDbLink.

Fields

link_field: &'static str

value: EpicsValue

ArmWatchdog

(Re)arm this record’s monitor watchdog — C histogramRecord.c::wdogInit (:126-152), whose callbackRequestDelayed(&pcallback->callback, prec->sdel) starts (or restarts) the periodic Record::watchdog_fire tick.

Emitted from a record’s special() when the put changed the watchdog’s period (histogram SDEL is special(SPC_RESET) precisely so it can re-arm, histogramRecord.c:266-268). The framework also arms every record’s watchdog once at iocInit, which is C’s other wdogInit call site (init_record pass 1, :168).

Arming supersedes any tick already pending for the record, exactly as C’s callbackRequestDelayed replaces an outstanding delayed callback.

CancelReprocess

Cancel this record’s outstanding async re-entry (C callbackCancelDelayed): the framework advances the record’s re-entry generation so any pending ReprocessAfter timer or WriteDbLinkNotify completion re-entry becomes a structural no-op (the AsyncToken gate), with no runtime “is-aborted” check on the re-entry path. Used by sseq ABORT to drop a pending DLYn delay or WAITn wait; the record resets its own sequence state in the same process() cycle that emits this.

Trait Implementations

impl Clone for ProcessAction

fn clone(&self) -> ProcessAction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ProcessAction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for ProcessAction

fn eq(&self, other: &ProcessAction) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ProcessAction