asyn-rs 0.30.1

//! Record field tables generated from the vendored EPICS `.dbd` record
//! declarations — the machine-readable spec every `FieldDesc` used to be
//! hand-copied from.
//!
//! @generated by `tools/dbd-codegen` from `crates/asyn-rs/dbd/*.dbd`.
//! DO NOT EDIT. Re-run `cargo run -p dbd-codegen -- --write` after changing a
//! vendored `.dbd`. Drift is caught by `dbd_codegen::tests::generated_files_are_not_stale`,
//! which `cargo nextest run` executes — locally and in CI — so a stale table
//! is a failing test, not a comment asking you to remember.
//!
//! What is *not* here, and why:
//!
//! * **`dbCommon` fields.** The port models them once in
//!   [`CommonFields`](epics_base_rs::server::record::CommonFields), so splicing them
//!   into every record table would double-declare them. Base's table emits
//!   them separately as `DB_COMMON_FIELDS` so the two models can be reconciled
//!   (and so a `dbCommon` addition is a diff, not a silent gap).
//! * **`DBF_NOACCESS` rows whose `extra(...)` names a pointer or an
//!   array** (`RSET`, `DPVT`, `MLOK`, `BPTR`, `PPN`, ...). C keeps
//!   `sizeof` the struct member in `pdbFldDes->size`, and neither a
//!   pointer (whose C value is an address no two IOCs agree on) nor an
//!   array (whose width is its bound, not its element) has one this port
//!   can state, so the *descriptor* is dropped rather than invented —
//!   but the NAME is kept (`record_noaccess_fields`): C's `dbNameToAddr`
//!   resolves them, so a SEARCH for `REC.BPTR` is answered and the
//!   refusal lands at channel creation, and the search gate needs the
//!   names to do the same.
//!
//!   A row whose `extra(...)` names a plain scalar — `dbCommon`'s `BKPT`
//!   and `TIME` — is CARRIED, descriptor and width both, because `dbpr`
//!   prints its bytes and `dba` reports its `Field Size` and both read
//!   the declaration. Carried is not servable: `FieldDesc::unreadable`
//!   is what refuses the read, so the SEARCH is answered off the
//!   descriptor instead of off the name list.

#![allow(clippy::all)]

use epics_base_rs::server::record::DbLinkType;
use epics_base_rs::server::record::FieldDesc;

// ---------------------------------------------------------------------
// `menu(...)` choice tables. The index is the stored `epicsEnum16` and is
// wire-visible (a `DBF_MENU` field is served as `DBR_ENUM`), so the order
// here is the `.dbd` declaration order, verbatim.
// ---------------------------------------------------------------------

/// Every `menu()` declared by a vendored `.dbd`, keyed by its EPICS name.
///
/// This is the table `get_enum_strs` answers a `DBF_MENU` field from: the
/// field's [`FieldDesc::menu`] already points at its choices, and this map
/// exists for the by-name lookups (`.db` loading, `dbpr`).
pub fn menu_choices(menu: &str) -> Option<&'static [&'static str]> {
    let _ = menu;
    None
}

/// Every `menu()` this target declares: EPICS name, `choice()` identifiers,
/// and choice values — the three columns `dbWriteMenuFP` prints
/// (`dbStaticLib.c:919-924`), which is what `dbDumpMenu` reports.
///
/// C walks `pdbbase->menuList` in `.dbd` LOAD order. A compiled-in table has
/// no load order, so the rows are in name order; the per-menu choice order is
/// still the `.dbd` order, because that one is the wire-visible index.
pub static MENUS: &[(&str, &[&str], &[&str])] = &[];

/// Every `variable()` this target's `.dbd`s declare, as EPICS name and
/// declared type — the two columns `dbWriteVariableFP` prints
/// (`dbStaticLib.c:1136-1149`), which is what `dbDumpVariable` reports.
///
/// Name order, which is also C's: `dbVariable` appends in load order, but
/// the loaded `.dbd` is `dbExpand` output and that tool emits each
/// declaration family sorted (measured in an installed `softIoc.dbd`).
pub static VARIABLES: &[(&str, &str)] = &[];

// ---------------------------------------------------------------------
// Per-record-type field tables. Record-*own* fields only: `dbCommon` is
// modelled separately (see the module docs).
// ---------------------------------------------------------------------

// ---------------------------------------------------------------------
// Per-record-type device menus (C `dbDeviceMenu`), in `.dbd` declaration
// order. The index is wire-visible: it IS the value of the DTYP field.
// ---------------------------------------------------------------------

/// `device(aai, ...)` choices, in declaration order.
pub static DEVICE_MENU_AAI: &[&str] = &[
    "asynInt8ArrayIn",
    "asynInt16ArrayIn",
    "asynInt32ArrayIn",
    "asynFloat32ArrayIn",
    "asynFloat64ArrayIn",
    "asynInt64ArrayIn",
];

/// `device(aao, ...)` choices, in declaration order.
pub static DEVICE_MENU_AAO: &[&str] = &[
    "asynInt8ArrayOut",
    "asynInt16ArrayOut",
    "asynInt32ArrayOut",
    "asynFloat32ArrayOut",
    "asynFloat64ArrayOut",
    "asynInt64ArrayOut",
];

/// `device(ai, ...)` choices, in declaration order.
pub static DEVICE_MENU_AI: &[&str] = &[
    "asynInt32",
    "asynInt32Average",
    "asynFloat64",
    "asynFloat64Average",
    "asynInt64",
];

/// `device(ao, ...)` choices, in declaration order.
pub static DEVICE_MENU_AO: &[&str] = &["asynInt32", "asynFloat64", "asynInt64"];

/// `device(bi, ...)` choices, in declaration order.
pub static DEVICE_MENU_BI: &[&str] = &["asynInt32", "asynUInt32Digital"];

/// `device(bo, ...)` choices, in declaration order.
pub static DEVICE_MENU_BO: &[&str] = &["asynInt32", "asynUInt32Digital"];

/// `device(int64in, ...)` choices, in declaration order.
pub static DEVICE_MENU_INT64IN: &[&str] = &["asynInt64"];

/// `device(int64out, ...)` choices, in declaration order.
pub static DEVICE_MENU_INT64OUT: &[&str] = &["asynInt64"];

/// `device(longin, ...)` choices, in declaration order.
pub static DEVICE_MENU_LONGIN: &[&str] = &["asynInt32", "asynUInt32Digital", "asynInt64"];

/// `device(longout, ...)` choices, in declaration order.
pub static DEVICE_MENU_LONGOUT: &[&str] = &["asynInt32", "asynUInt32Digital", "asynInt64"];

/// `device(lsi, ...)` choices, in declaration order.
pub static DEVICE_MENU_LSI: &[&str] = &[
    "asynOctetCmdResponse",
    "asynOctetWriteRead",
    "asynOctetRead",
];

/// `device(lso, ...)` choices, in declaration order.
pub static DEVICE_MENU_LSO: &[&str] = &["asynOctetWrite"];

/// `device(mbbi, ...)` choices, in declaration order.
pub static DEVICE_MENU_MBBI: &[&str] = &["asynInt32", "asynUInt32Digital"];

/// `device(mbbiDirect, ...)` choices, in declaration order.
pub static DEVICE_MENU_MBBIDIRECT: &[&str] = &["asynUInt32Digital"];

/// `device(mbbo, ...)` choices, in declaration order.
pub static DEVICE_MENU_MBBO: &[&str] = &["asynInt32", "asynUInt32Digital"];

/// `device(mbboDirect, ...)` choices, in declaration order.
pub static DEVICE_MENU_MBBODIRECT: &[&str] = &["asynUInt32Digital"];

/// `device(printf, ...)` choices, in declaration order.
pub static DEVICE_MENU_PRINTF: &[&str] = &["asynOctetWrite"];

/// `device(stringin, ...)` choices, in declaration order.
pub static DEVICE_MENU_STRINGIN: &[&str] = &[
    "asynOctetCmdResponse",
    "asynOctetWriteRead",
    "asynOctetRead",
];

/// `device(stringout, ...)` choices, in declaration order.
pub static DEVICE_MENU_STRINGOUT: &[&str] = &["asynOctetWrite"];

/// `device(waveform, ...)` choices, in declaration order.
pub static DEVICE_MENU_WAVEFORM: &[&str] = &[
    "asynOctetCmdResponse",
    "asynOctetWriteRead",
    "asynOctetRead",
    "asynOctetWrite",
    "asynOctetWriteBinary",
    "asynInt8ArrayIn",
    "asynInt8ArrayOut",
    "asynInt16ArrayIn",
    "asynInt16ArrayOut",
    "asynInt32ArrayIn",
    "asynInt32ArrayOut",
    "asynFloat32ArrayIn",
    "asynFloat32ArrayOut",
    "asynFloat64ArrayIn",
    "asynFloat64ArrayOut",
    "asynInt32TimeSeries",
    "asynFloat64TimeSeries",
    "asynInt64ArrayIn",
    "asynInt64ArrayOut",
    "asynInt64TimeSeries",
];

/// The device menu for a record type — the choices its `DTYP` field selects
/// among, in `.dbd` declaration order. `None` for a record type that declares
/// no device support: C has no `dbDeviceMenu` for it, and its DTYP renders as
/// the empty string.
pub fn device_menu(record_type: &str) -> Option<&'static [&'static str]> {
    Some(match record_type {
        "aai" => DEVICE_MENU_AAI,
        "aao" => DEVICE_MENU_AAO,
        "ai" => DEVICE_MENU_AI,
        "ao" => DEVICE_MENU_AO,
        "bi" => DEVICE_MENU_BI,
        "bo" => DEVICE_MENU_BO,
        "int64in" => DEVICE_MENU_INT64IN,
        "int64out" => DEVICE_MENU_INT64OUT,
        "longin" => DEVICE_MENU_LONGIN,
        "longout" => DEVICE_MENU_LONGOUT,
        "lsi" => DEVICE_MENU_LSI,
        "lso" => DEVICE_MENU_LSO,
        "mbbi" => DEVICE_MENU_MBBI,
        "mbbiDirect" => DEVICE_MENU_MBBIDIRECT,
        "mbbo" => DEVICE_MENU_MBBO,
        "mbboDirect" => DEVICE_MENU_MBBODIRECT,
        "printf" => DEVICE_MENU_PRINTF,
        "stringin" => DEVICE_MENU_STRINGIN,
        "stringout" => DEVICE_MENU_STRINGOUT,
        "waveform" => DEVICE_MENU_WAVEFORM,
        _ => return None,
    })
}

/// The record types [`device_menu`] returns `Some` for, in `.dbd` name order.
pub static DEVICE_MENU_RECORD_TYPES: &[&str] = &[
    "aai",
    "aao",
    "ai",
    "ao",
    "bi",
    "bo",
    "int64in",
    "int64out",
    "longin",
    "longout",
    "lsi",
    "lso",
    "mbbi",
    "mbbiDirect",
    "mbbo",
    "mbboDirect",
    "printf",
    "stringin",
    "stringout",
    "waveform",
];

// ---------------------------------------------------------------------
// Per-(record type, DTYP) device LINK TYPE (C `devSup::link_type`), the
// half of the `device()` declaration `dbCanSetLink` enforces.
// ---------------------------------------------------------------------

/// `device(aai, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_AAI: &[(&str, DbLinkType)] = &[
    ("asynInt8ArrayIn", DbLinkType::InstIo),
    ("asynInt16ArrayIn", DbLinkType::InstIo),
    ("asynInt32ArrayIn", DbLinkType::InstIo),
    ("asynFloat32ArrayIn", DbLinkType::InstIo),
    ("asynFloat64ArrayIn", DbLinkType::InstIo),
    ("asynInt64ArrayIn", DbLinkType::InstIo),
];

/// `device(aao, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_AAO: &[(&str, DbLinkType)] = &[
    ("asynInt8ArrayOut", DbLinkType::InstIo),
    ("asynInt16ArrayOut", DbLinkType::InstIo),
    ("asynInt32ArrayOut", DbLinkType::InstIo),
    ("asynFloat32ArrayOut", DbLinkType::InstIo),
    ("asynFloat64ArrayOut", DbLinkType::InstIo),
    ("asynInt64ArrayOut", DbLinkType::InstIo),
];

/// `device(ai, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_AI: &[(&str, DbLinkType)] = &[
    ("asynInt32", DbLinkType::InstIo),
    ("asynInt32Average", DbLinkType::InstIo),
    ("asynFloat64", DbLinkType::InstIo),
    ("asynFloat64Average", DbLinkType::InstIo),
    ("asynInt64", DbLinkType::InstIo),
];

/// `device(ao, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_AO: &[(&str, DbLinkType)] = &[
    ("asynInt32", DbLinkType::InstIo),
    ("asynFloat64", DbLinkType::InstIo),
    ("asynInt64", DbLinkType::InstIo),
];

/// `device(bi, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_BI: &[(&str, DbLinkType)] = &[
    ("asynInt32", DbLinkType::InstIo),
    ("asynUInt32Digital", DbLinkType::InstIo),
];

/// `device(bo, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_BO: &[(&str, DbLinkType)] = &[
    ("asynInt32", DbLinkType::InstIo),
    ("asynUInt32Digital", DbLinkType::InstIo),
];

/// `device(int64in, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_INT64IN: &[(&str, DbLinkType)] = &[("asynInt64", DbLinkType::InstIo)];

/// `device(int64out, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_INT64OUT: &[(&str, DbLinkType)] = &[("asynInt64", DbLinkType::InstIo)];

/// `device(longin, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_LONGIN: &[(&str, DbLinkType)] = &[
    ("asynInt32", DbLinkType::InstIo),
    ("asynUInt32Digital", DbLinkType::InstIo),
    ("asynInt64", DbLinkType::InstIo),
];

/// `device(longout, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_LONGOUT: &[(&str, DbLinkType)] = &[
    ("asynInt32", DbLinkType::InstIo),
    ("asynUInt32Digital", DbLinkType::InstIo),
    ("asynInt64", DbLinkType::InstIo),
];

/// `device(lsi, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_LSI: &[(&str, DbLinkType)] = &[
    ("asynOctetCmdResponse", DbLinkType::InstIo),
    ("asynOctetWriteRead", DbLinkType::InstIo),
    ("asynOctetRead", DbLinkType::InstIo),
];

/// `device(lso, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_LSO: &[(&str, DbLinkType)] = &[("asynOctetWrite", DbLinkType::InstIo)];

/// `device(mbbi, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_MBBI: &[(&str, DbLinkType)] = &[
    ("asynInt32", DbLinkType::InstIo),
    ("asynUInt32Digital", DbLinkType::InstIo),
];

/// `device(mbbiDirect, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_MBBIDIRECT: &[(&str, DbLinkType)] =
    &[("asynUInt32Digital", DbLinkType::InstIo)];

/// `device(mbbo, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_MBBO: &[(&str, DbLinkType)] = &[
    ("asynInt32", DbLinkType::InstIo),
    ("asynUInt32Digital", DbLinkType::InstIo),
];

/// `device(mbboDirect, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_MBBODIRECT: &[(&str, DbLinkType)] =
    &[("asynUInt32Digital", DbLinkType::InstIo)];

/// `device(printf, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_PRINTF: &[(&str, DbLinkType)] =
    &[("asynOctetWrite", DbLinkType::InstIo)];

/// `device(stringin, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_STRINGIN: &[(&str, DbLinkType)] = &[
    ("asynOctetCmdResponse", DbLinkType::InstIo),
    ("asynOctetWriteRead", DbLinkType::InstIo),
    ("asynOctetRead", DbLinkType::InstIo),
];

/// `device(stringout, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_STRINGOUT: &[(&str, DbLinkType)] =
    &[("asynOctetWrite", DbLinkType::InstIo)];

/// `device(waveform, LINK_TYPE, ...)` — the link type each DTYP choice demands.
pub static DEVICE_LINK_TYPES_WAVEFORM: &[(&str, DbLinkType)] = &[
    ("asynOctetCmdResponse", DbLinkType::InstIo),
    ("asynOctetWriteRead", DbLinkType::InstIo),
    ("asynOctetRead", DbLinkType::InstIo),
    ("asynOctetWrite", DbLinkType::InstIo),
    ("asynOctetWriteBinary", DbLinkType::InstIo),
    ("asynInt8ArrayIn", DbLinkType::InstIo),
    ("asynInt8ArrayOut", DbLinkType::InstIo),
    ("asynInt16ArrayIn", DbLinkType::InstIo),
    ("asynInt16ArrayOut", DbLinkType::InstIo),
    ("asynInt32ArrayIn", DbLinkType::InstIo),
    ("asynInt32ArrayOut", DbLinkType::InstIo),
    ("asynFloat32ArrayIn", DbLinkType::InstIo),
    ("asynFloat32ArrayOut", DbLinkType::InstIo),
    ("asynFloat64ArrayIn", DbLinkType::InstIo),
    ("asynFloat64ArrayOut", DbLinkType::InstIo),
    ("asynInt32TimeSeries", DbLinkType::InstIo),
    ("asynFloat64TimeSeries", DbLinkType::InstIo),
    ("asynInt64ArrayIn", DbLinkType::InstIo),
    ("asynInt64ArrayOut", DbLinkType::InstIo),
    ("asynInt64TimeSeries", DbLinkType::InstIo),
];

/// The link type the named `DTYP` of `record_type` demands of its `INP`/`OUT`.
///
/// `None` when no vendored `.dbd` declares that `device()` — a downstream
/// crate registering its device support at runtime (asyn, motor) brings no
/// `.dbd`, so there is no declaration to enforce and none is invented.
pub fn device_link_type(record_type: &str, dtyp: &str) -> Option<DbLinkType> {
    let table = match record_type {
        "aai" => DEVICE_LINK_TYPES_AAI,
        "aao" => DEVICE_LINK_TYPES_AAO,
        "ai" => DEVICE_LINK_TYPES_AI,
        "ao" => DEVICE_LINK_TYPES_AO,
        "bi" => DEVICE_LINK_TYPES_BI,
        "bo" => DEVICE_LINK_TYPES_BO,
        "int64in" => DEVICE_LINK_TYPES_INT64IN,
        "int64out" => DEVICE_LINK_TYPES_INT64OUT,
        "longin" => DEVICE_LINK_TYPES_LONGIN,
        "longout" => DEVICE_LINK_TYPES_LONGOUT,
        "lsi" => DEVICE_LINK_TYPES_LSI,
        "lso" => DEVICE_LINK_TYPES_LSO,
        "mbbi" => DEVICE_LINK_TYPES_MBBI,
        "mbbiDirect" => DEVICE_LINK_TYPES_MBBIDIRECT,
        "mbbo" => DEVICE_LINK_TYPES_MBBO,
        "mbboDirect" => DEVICE_LINK_TYPES_MBBODIRECT,
        "printf" => DEVICE_LINK_TYPES_PRINTF,
        "stringin" => DEVICE_LINK_TYPES_STRINGIN,
        "stringout" => DEVICE_LINK_TYPES_STRINGOUT,
        "waveform" => DEVICE_LINK_TYPES_WAVEFORM,
        _ => return None,
    };
    table
        .iter()
        .find(|(name, _)| name.eq_ignore_ascii_case(dtyp))
        .map(|(_, lt)| *lt)
}

/// The record-own field table for a record type name, or `None` for a type
/// no vendored `.dbd` declares.
pub fn record_fields(record_type: &str) -> Option<&'static [FieldDesc]> {
    let _ = record_type;
    None
}

/// The record-own `DBF_NOACCESS` internal names for a record type — fields
/// C's `dbNameToAddr` resolves (a SEARCH is answered) but whose channel is
/// refused at creation (`mapDBFToDBR` -> `DBR_NOACCESS`). Empty for a type
/// declaring none, `None` for a type no vendored `.dbd` declares.
pub fn record_noaccess_fields(record_type: &str) -> Option<&'static [&'static str]> {
    let _ = record_type;
    None
}

/// Every field a record type declares, in C's `papFldDes` order — the order
/// `dbDumpRecordType` indexes and `link_ind`/`sortFldInd`/`indvalFlddes`
/// point into. Unlike `record_fields` this keeps the `DBF_NOACCESS`
/// internals and splices dbCommon where the `.dbd` puts its `include`, so
/// the index of a name here is C's own `indRecordType` for it.
pub fn record_declaration_order(record_type: &str) -> Option<&'static [&'static str]> {
    let _ = record_type;
    None
}

/// C's `pdbRecordType->no_prompt`: how many of `record_declaration_order`'s
/// declarations carry a `promptgroup(...)` (`dbLexRoutines.c:752`). Counted
/// here because the port drops `promptgroup` at emit, so it cannot be
/// recovered from the field tables.
pub fn record_no_prompt(record_type: &str) -> Option<u16> {
    let _ = record_type;
    None
}

/// Every record type a vendored `.dbd` declares, in `.dbd` name order.
pub static RECORD_TYPES: &[&str] = &[];