🥮 mooncakes.io
    Sign in

    moonbit-iec104

    Portable IEC 60870-5-104 protocol core for SCADA, gateways, and deterministic simulation.

    iec104
    scada
    telecontrol
    protocol
    Download zip
    Author
    Version
    0.3.1
    License
    Apache-2.0
    Repository
    Last updated
    last month
    Downloads
    20

    #moonbit-iec104

    一个面向 SCADA、变电站自动化、配电网关和协议仿真的 IEC 60870-5-104 协议核心。项目使用 MoonBit 编写，库层不绑定 TCP 实现或操作系统 I/O，便于嵌入网关、测试工具和确定性仿真器。

    #项目定位

    本项目覆盖 IEC 104 链路层与常用应用层数据模型，重点放在可验证的二进制编解码、链路状态、序号窗口、信息对象和边界行为。网络传输由调用方接入，协议核心因此可以在 native、wasm-gc 等目标上复用。

    #核心能力

    • APCI I/S/U 帧编解码、15 位发送/接收序号和序号窗口。
    • STARTDT、STOPDT、TESTFR 链路状态机、定时器和流式 APDU 解析。
    • IEC 104 常用 Type ID、VSQ、传送原因、公共地址和信息体地址模型。
    • 单点、双点、步位、归一化值、标度值、短浮点值、累计量及命令对象。
    • CP24Time2a、CP56Time2a、质量描述符、地址序列和带时标 ASDU 编解码。
    • 点表、历史变更、总召唤/计数量召唤、读命令、时钟同步和命令策略。
    • 站点数据库、事务提交、质量门控、历史归档、遥测死区和告警生命周期。
    • 命令调度、文件分片传输、冗余切换、服务依赖编排和传输会话管理。
    • 资源限制、重放保护、CRC、帧统计、健康报告、契约向量和确定性工作负载。

    #快速开始

    需要 MoonBit stable 工具链。首次使用时执行：

    moon update
moon fmt
moon check --deny-warn --target all
moon build --target wasm-gc
moon test --deny-warn --target wasm-gc

    运行示例 CLI：

    moon run cmd/main
moon run cmd/main -- --help
moon run cmd/main -- --benchmark
moon run cmd/main -- --application-benchmark

    在库代码中构造并编码一个 I 帧：

    ///|
    let payload = @hhxhhx78/moonbit-iec104.normalized_value_asdu(3, 1, 2300, 0)

    ///|
    let apdu = @hhxhhx78/moonbit-iec104.encode_frame(
      @hhxhhx78/moonbit-iec104.information_frame(0, 0, payload),
    )

    #CLI

    cmd/main 提供一个不依赖外部服务的可重复示例：默认编码一个归一化测量值 I 帧；--benchmark 执行固定的 10,000 帧编解码工作负载；--application-benchmark 执行站点、遥测、命令、文件和仿真服务工作负载；--help 显示用法。宿主机耗时由基准命令外部测量，避免把平台时钟引入协议核心。

    #架构

    层次主要文件职责
    链路与帧frame_types.mbt, codec.mbt, validation.mbt, state_machine.mbtAPCI、ASDU 基础模型、校验和链路状态
    应用数据protocol_domain.mbt, quality.mbt, time_tags.mbt, application_objects.mbt, extended_asdu.mbtType ID、地址、质量、时标和信息对象
    服务与状态transport_layer.mbt, station_database.mbt, telemetry_pipeline.mbt, command_scheduler.mbt, point_store.mbt传输会话、站点数据库、遥测、命令和点表
    运行时能力file_transfer.mbt, historical_archive.mbt, redundancy_manager.mbt, service_registry.mbt, runtime_facade.mbt文件、归档、冗余、依赖编排和统一运行时
    工具与可靠性wire_tools.mbt, security_limits.mbt, diagnostics_metrics.mbt, health_report.mbt字节工具、资源保护、指标和诊断
    仿真与契约simulation.mbt, conformance_catalog.mbt, protocol_profiles.mbt, benchmark_api.mbt确定性仿真、类型目录、能力协商和基准接口
    示例cmd/main可运行的最小 CLI

    #基准

    基准工作负载由 run_benchmark_workload 定义，输入、输出字节数和 CRC 校验和均是确定的；宿主机实测结果记录在 BENCHMARKS.md，包含执行环境、命令、重复次数和原始输出。重新测量：

    1..5 | ForEach-Object { Measure-Command { moon run cmd/main -- --benchmark } }

    该数据用于比较同一环境下的回归趋势，不代表所有设备或网络部署的吞吐承诺。

    #测试

    测试覆盖帧编解码、链路状态、Type ID 和地址边界、CP24/CP56 闰年与无效日期、质量位、签名测量值、ASDU 截断/尾随字节、序号回绕、流式输入、点表容量与事务冲突、服务依赖与租约、质量门控、文件分片顺序、遥测死区、命令幂等、资源限制、CRC 和确定性基准。推荐在本地分别运行：

    moon check --deny-warn --target all
moon test --deny-warn --target wasm-gc
moon test --deny-warn --target native

    #CI

    .github/workflows/check.yml 在 Ubuntu、macOS 和 Windows 上安装 MoonBit stable，执行版本检查、依赖更新、格式检查、接口文件一致性、所有目标检查、wasm-gc 构建和测试。CI 使用最小只读仓库权限；本地若缺少某个后端运行时，应以对应平台 CI 结果和明确的本地环境提示为准。

    #许可证

    本项目采用 Apache License 2.0。

    AdmissionDecision

    source
    pub enum AdmissionDecision {
      AcceptedAdmission
      RejectedAdmission(Diagnostic)
    } derive(
    Debug    )

    AlarmEvent

    source
    pub struct AlarmEvent {
      station : CommonAddress
      address : InformationAddress
      name : String
      severity : AlarmSeverity
      active : Bool
      value : Float
      timestamp : Int
      message : String
    } derive(Eq, 
    Debug    )

    An alarm lifecycle event.

    AlarmEvent::active

    source
    fn AlarmEvent::active(self : AlarmEvent) -> Bool

    AlarmEvent::address

    source

    AlarmEvent::message

    source
    fn AlarmEvent::message(self : AlarmEvent) -> String

    AlarmEvent::name

    source
    fn AlarmEvent::name(self : AlarmEvent) -> String

    AlarmEvent::severity

    source
    fn AlarmEvent::severity(self : AlarmEvent) -> AlarmSeverity

    AlarmEvent::station

    source
    fn AlarmEvent::station(self : AlarmEvent) -> CommonAddress

    AlarmEvent::timestamp

    source
    fn AlarmEvent::timestamp(self : AlarmEvent) -> Int

    AlarmEvent::value

    source
    fn AlarmEvent::value(self : AlarmEvent) -> Float

    AlarmJournal

    source
    pub struct AlarmJournal {
      active : Map[String, AlarmRecord]
      events : Array[AlarmJournalEvent]
      event_limit : Int
      next_sequence : Int
      metrics : AlarmJournalMetrics
    } derive(
    Debug    )

    Bounded alarm journal with acknowledge, shelf and escalation workflows.

    AlarmJournal::acknowledge

    source
    fn AlarmJournal::acknowledge(self : AlarmJournal, key : String, operator : String, timestamp : Int) -> Result[AlarmRecord, String]

    AlarmJournal::active_count

    source
    fn AlarmJournal::active_count(self : AlarmJournal) -> Int

    AlarmJournal::all

    source

    AlarmJournal::escalate

    source
    fn AlarmJournal::escalate(self : AlarmJournal, key : String, operator : String, timestamp : Int) -> Result[AlarmRecord, String]

    AlarmJournal::events

    source

    AlarmJournal::get

    source
    fn AlarmJournal::get(self : AlarmJournal, key : String) -> AlarmRecord?

    AlarmJournal::ingest

    source
    fn AlarmJournal::ingest(self : AlarmJournal, event : AlarmEvent) -> Result[AlarmRecord, String]

    AlarmJournal::metrics

    source

    AlarmJournal::new

    source
    fn AlarmJournal::new(event_limit? : Int) -> Result[AlarmJournal, String]

    AlarmJournal::shelve

    source
    fn AlarmJournal::shelve(self : AlarmJournal, key : String, operator : String, until : Int, timestamp : Int) -> Result[AlarmRecord, String]

    AlarmJournal::unshelve_expired

    source
    fn AlarmJournal::unshelve_expired(self : AlarmJournal, timestamp : Int) -> Int

    AlarmJournalAction

    source
    pub enum AlarmJournalAction {
      AlarmOpened
      AlarmUpdated
      AlarmAcknowledgedAction
      AlarmShelvedAction
      AlarmUnshelvedAction
      AlarmEscalatedAction
      AlarmClearedAction
    } derive(Eq, 
    Debug    )

    AlarmJournalEvent

    source
    pub struct AlarmJournalEvent {
      sequence : Int
      timestamp : Int
      key : String
      action : AlarmJournalAction
      operator : String
      detail : String
    } derive(Eq, 
    Debug    )

    AlarmJournalEvent::action

    source

    AlarmJournalEvent::detail

    source
    fn AlarmJournalEvent::detail(self : AlarmJournalEvent) -> String

    AlarmJournalEvent::key

    source
    fn AlarmJournalEvent::key(self : AlarmJournalEvent) -> String

    AlarmJournalEvent::operator

    source
    fn AlarmJournalEvent::operator(self : AlarmJournalEvent) -> String

    AlarmJournalEvent::sequence

    source
    fn AlarmJournalEvent::sequence(self : AlarmJournalEvent) -> Int

    AlarmJournalEvent::timestamp

    source
    fn AlarmJournalEvent::timestamp(self : AlarmJournalEvent) -> Int

    AlarmJournalMetrics

    source
    pub struct AlarmJournalMetrics {
      opened : Int
      acknowledged : Int
      shelved : Int
      escalated : Int
      cleared : Int
    } derive(Eq, 
    Debug    )

    AlarmJournalMetrics::acknowledged

    source
    fn AlarmJournalMetrics::acknowledged(self : AlarmJournalMetrics) -> Int

    AlarmJournalMetrics::cleared

    source
    fn AlarmJournalMetrics::cleared(self : AlarmJournalMetrics) -> Int

    AlarmJournalMetrics::escalated

    source
    fn AlarmJournalMetrics::escalated(self : AlarmJournalMetrics) -> Int

    AlarmJournalMetrics::new

    source

    AlarmJournalMetrics::opened

    source
    fn AlarmJournalMetrics::opened(self : AlarmJournalMetrics) -> Int

    AlarmJournalMetrics::shelved

    source
    fn AlarmJournalMetrics::shelved(self : AlarmJournalMetrics) -> Int

    AlarmLifecycle

    source
    pub enum AlarmLifecycle {
      AlarmActive
      AlarmAcknowledged
      AlarmShelved
      AlarmCleared
      AlarmEscalated
    } derive(Eq, 
    Debug    )

    Lifecycle state tracked independently from telemetry threshold evaluation.

    AlarmRecord

    source
    pub struct AlarmRecord {
      key : String
      station : CommonAddress
      address : InformationAddress
      name : String
      severity : AlarmSeverity
      lifecycle : AlarmLifecycle
      first_seen : Int
      last_seen : Int
      occurrences : Int
      acknowledged_by : String?
      acknowledged_at : Int?
      shelf_until : Int?
      last_value : Float
      message : String
    } derive(
    Debug    )

    AlarmRecord::acknowledged_at

    source
    fn AlarmRecord::acknowledged_at(self : AlarmRecord) -> Int?

    AlarmRecord::acknowledged_by

    source
    fn AlarmRecord::acknowledged_by(self : AlarmRecord) -> String?

    AlarmRecord::address

    source

    AlarmRecord::first_seen

    source
    fn AlarmRecord::first_seen(self : AlarmRecord) -> Int

    AlarmRecord::key

    source
    fn AlarmRecord::key(self : AlarmRecord) -> String

    AlarmRecord::last_seen

    source
    fn AlarmRecord::last_seen(self : AlarmRecord) -> Int

    AlarmRecord::last_value

    source
    fn AlarmRecord::last_value(self : AlarmRecord) -> Float

    AlarmRecord::lifecycle

    source
    fn AlarmRecord::lifecycle(self : AlarmRecord) -> AlarmLifecycle

    AlarmRecord::message

    source
    fn AlarmRecord::message(self : AlarmRecord) -> String

    AlarmRecord::name

    source
    fn AlarmRecord::name(self : AlarmRecord) -> String

    AlarmRecord::occurrences

    source
    fn AlarmRecord::occurrences(self : AlarmRecord) -> Int

    AlarmRecord::severity

    source
    fn AlarmRecord::severity(self : AlarmRecord) -> AlarmSeverity

    AlarmRecord::shelf_until

    source
    fn AlarmRecord::shelf_until(self : AlarmRecord) -> Int?

    AlarmRecord::station

    source
    fn AlarmRecord::station(self : AlarmRecord) -> CommonAddress

    AlarmRule

    source
    pub struct AlarmRule {
      low : Float?
      high : Float?
      severity : AlarmSeverity
      hysteresis : Float
      name : String
    } derive(Eq, 
    Debug    )

    Threshold used for alarm creation and clearing.

    AlarmRule::high

    source
    fn AlarmRule::high(self : AlarmRule) -> Float?

    AlarmRule::hysteresis

    source
    fn AlarmRule::hysteresis(self : AlarmRule) -> Float

    AlarmRule::low

    source
    fn AlarmRule::low(self : AlarmRule) -> Float?

    AlarmRule::name

    source
    fn AlarmRule::name(self : AlarmRule) -> String

    AlarmRule::new

    source
    fn AlarmRule::new(name : String, severity : AlarmSeverity, low? : Float, high? : Float, hysteresis? : Float) -> Result[AlarmRule, String]

    AlarmRule::severity

    source
    fn AlarmRule::severity(self : AlarmRule) -> AlarmSeverity

    AlarmSeverity

    source
    pub enum AlarmSeverity {
      InformationalAlarm
      WarningAlarm
      MajorAlarm
      CriticalAlarm
    } derive(Eq, 
    Debug    )

    Alarm severity emitted by a threshold stage.

    AlarmSeverity::weight

    source
    fn AlarmSeverity::weight(self : AlarmSeverity) -> Int

    ApduParseResult

    source
    pub enum ApduParseResult {
      NeedMore(Int)
      Complete(Frame, Int)
      Invalid(Diagnostic)
    } derive(
    Debug    )

    Incremental APDU parsing result for TCP or serial gateway adapters.

    ApduStreamDecoder

    source
    pub struct ApduStreamDecoder {
      buffer : Array[Byte]
      max_apdu : Int
    } derive(
    Debug    )

    A portable byte accumulator for stream transports.

    ApduStreamDecoder::available_frames

    source
    fn ApduStreamDecoder::available_frames(self : ApduStreamDecoder) -> Int

    Number of complete frames available in a buffered stream.

    ApduStreamDecoder::buffered

    source
    fn ApduStreamDecoder::buffered(self : ApduStreamDecoder) -> Int

    ApduStreamDecoder::clear

    source
    fn ApduStreamDecoder::clear(self : ApduStreamDecoder) -> Unit

    ApduStreamDecoder::new

    source
    fn ApduStreamDecoder::new(max_apdu? : Int) -> Result[ApduStreamDecoder, String]

    ApduStreamDecoder::next

    source

    Parse and remove the first complete APDU, preserving partial data.

    ApduStreamDecoder::push

    source
    fn ApduStreamDecoder::push(self : ApduStreamDecoder, data : Bytes) -> Result[Int, Diagnostic]

    ApplicationBenchmarkWorkload

    source
    pub enum ApplicationBenchmarkWorkload {
      CodecWorkload
      DatabaseWorkload
      TelemetryWorkload
      SchedulerWorkload
      FileWorkload
      ScenarioWorkload
    } derive(Eq, 
    Debug    )

    Benchmark workload families used by the local CLI and CI smoke checks.

    ApplicationObject

    source
    pub struct ApplicationObject {
      address : InformationAddress
      type_id : ApplicationType
      value : ApplicationValue
      time_tag : TimeTag?
    } derive(Eq, 
    Debug    )

    An address-qualified application object with an optional time tag.

    ApplicationObject::address

    source

    ApplicationObject::is_command

    source
    fn ApplicationObject::is_command(self : ApplicationObject) -> Bool

    ApplicationObject::is_measurement

    source
    fn ApplicationObject::is_measurement(self : ApplicationObject) -> Bool

    ApplicationObject::new

    source
    fn ApplicationObject::new(address : InformationAddress, value : ApplicationValue, time_tag? : TimeTag) -> Result[ApplicationObject, String]

    Construct an application object and optionally attach its standard time tag.

    ApplicationObject::summary

    source
    fn ApplicationObject::summary(self : ApplicationObject) -> (Int, Int, Int, Bool)

    Return a type-tagged object as a stable compact summary tuple.

    ApplicationObject::time_tag

    source

    ApplicationObject::type_id

    source

    ApplicationObject::validate

    source
    fn ApplicationObject::validate(self : ApplicationObject) -> Result[Unit, Diagnostic]

    Validate an application object before placing it in an ASDU.

    ApplicationObject::value

    source

    ApplicationType

    source
    pub enum ApplicationType {
      MSpNa
      MSpTa
      MDpNa
      MDpTa
      MStNa
      MStTa
      MBoNa
      MBoTa
      MMeNa
      MMeTa
      MMeNb
      MMeTb
      MMeNc
      MMeTc
      MItNa
      MItTa
      MEpTa
      MEpTb
      MEpTc
      MPsNa
      MMeNd
      MSpTb
      MDpTb
      MStTb
      MBoTb
      MMeTd
      MMeTe
      MMeTf
      MItTb
      MEpTd
      MEpTe
      MEpTf
      MEiNa
      CScNa
      CDcNa
      CRcNa
      CSeNa
      CSeNb
      CSeNc
      CBoNa
      CIcNa
      CCiNa
      CRdNa
      CCsNa
      CTsNa
      CRpNa
      UnknownType(Int)
    } derive(Eq, 
    Debug    )

    Standard IEC 104 application type identifiers.

    ApplicationType::has_time_tag

    source
    fn ApplicationType::has_time_tag(self : ApplicationType) -> Bool

    Whether a type carries a CP24 or CP56 time tag.

    ApplicationType::is_control

    source
    fn ApplicationType::is_control(self : ApplicationType) -> Bool

    Whether an application type belongs to control direction data.

    ApplicationType::is_monitoring

    source
    fn ApplicationType::is_monitoring(self : ApplicationType) -> Bool

    Whether an application type belongs to monitor direction data.

    ApplicationType::number

    source
    fn ApplicationType::number(self : ApplicationType) -> Int

    Return an IEC 104 type identifier number.

    ApplicationType::value_width

    source
    fn ApplicationType::value_width(self : ApplicationType) -> Int?

    Preferred information-object payload width, excluding IOA and time tag.

    ApplicationValue

    source
    pub enum ApplicationValue {
      SinglePointValue(SinglePointValue)
      DoublePointValue(DoublePointValue)
      StepPositionValue(StepPositionValue)
      BitStringValue(UInt)
      NormalizedMeasurement(NormalizedValue)
      ScaledMeasurement(ScaledValue)
      ShortFloatMeasurement(ShortFloatValue)
      BinaryCounterMeasurement(BinaryCounterValue)
      SingleCommand(Bool, Int)
      DoubleCommand(Int, Int)
      RegulatingStepCommand(Int, Int)
      NormalizedSetPoint(Int, Int)
      ScaledSetPoint(Int, Int)
      ShortFloatSetPoint(Float, Int)
      BitStringCommand(UInt)
      InterrogationCommand(Int)
      CounterInterrogationCommand(Int)
      ReadCommand
      ClockSyncCommand(Cp56Time)
      TestCommand(Int)
      ResetCommand(Int)
      DelayCommand(Int)
      EndOfInitialization(Int)
      RawValue(Bytes)
    } derive(Eq, 
    Debug    )

    Values carried by standard IEC 104 information objects.

    ArchiveBucket

    source
    pub struct ArchiveBucket {
      station : CommonAddress
      address : InformationAddress
      start : Int
      end : Int
      count : Int
      minimum : Float
      maximum : Float
      sum : Float
      invalid : Int
    } derive(Eq, 
    Debug    )

    ArchiveBucket::address

    source

    ArchiveBucket::average

    source
    fn ArchiveBucket::average(self : ArchiveBucket) -> Float

    ArchiveBucket::count

    source
    fn ArchiveBucket::count(self : ArchiveBucket) -> Int

    ArchiveBucket::end

    source
    fn ArchiveBucket::end(self : ArchiveBucket) -> Int

    ArchiveBucket::invalid

    source
    fn ArchiveBucket::invalid(self : ArchiveBucket) -> Int

    ArchiveBucket::maximum

    source
    fn ArchiveBucket::maximum(self : ArchiveBucket) -> Float

    ArchiveBucket::minimum

    source
    fn ArchiveBucket::minimum(self : ArchiveBucket) -> Float

    ArchiveBucket::start

    source
    fn ArchiveBucket::start(self : ArchiveBucket) -> Int

    ArchiveBucket::station

    source

    ArchiveBucket::sum

    source
    fn ArchiveBucket::sum(self : ArchiveBucket) -> Float

    ArchivePolicy

    source
    pub struct ArchivePolicy {
      maximum_samples : Int
      maximum_age : Int
      bucket_width : Int
      reject_invalid : Bool
    } derive(Eq, 
    Debug    )

    Retention policy for historical telemetry samples.

    ArchivePolicy::bucket_width

    source
    fn ArchivePolicy::bucket_width(self : ArchivePolicy) -> Int

    ArchivePolicy::maximum_age

    source
    fn ArchivePolicy::maximum_age(self : ArchivePolicy) -> Int

    ArchivePolicy::maximum_samples

    source
    fn ArchivePolicy::maximum_samples(self : ArchivePolicy) -> Int

    ArchivePolicy::new

    source
    fn ArchivePolicy::new(maximum_samples? : Int, maximum_age? : Int, bucket_width? : Int, reject_invalid? : Bool) -> Result[ArchivePolicy, String]

    ArchivePolicy::reject_invalid

    source
    fn ArchivePolicy::reject_invalid(self : ArchivePolicy) -> Bool

    ArchiveQuery

    source
    pub struct ArchiveQuery {
      station : CommonAddress?
      first_address : InformationAddress?
      last_address : InformationAddress?
      start : Int?
      end : Int?
      source : String?
      include_invalid : Bool
    } derive(Eq, 
    Debug    )

    Query over a station/address/time range.

    ArchiveQuery::address_range

    source
    fn ArchiveQuery::address_range(self : ArchiveQuery, first : InformationAddress, last : InformationAddress) -> ArchiveQuery

    ArchiveQuery::all

    source

    ArchiveQuery::from_source

    source
    fn ArchiveQuery::from_source(self : ArchiveQuery, source : String) -> ArchiveQuery

    ArchiveQuery::station

    source
    fn ArchiveQuery::station(self : ArchiveQuery, value : CommonAddress) -> ArchiveQuery

    ArchiveQuery::time_range

    source
    fn ArchiveQuery::time_range(self : ArchiveQuery, start : Int, end : Int) -> ArchiveQuery

    ArchiveQuery::with_invalid

    source
    fn ArchiveQuery::with_invalid(self : ArchiveQuery, include_invalid_value : Bool) -> ArchiveQuery

    ArchiveStore

    source
    pub struct ArchiveStore {
      samples : Array[ArchivedSample]
      policy : ArchivePolicy
      next_sequence : Int
      evicted : Int
    } derive(
    Debug    )

    ArchiveStore::append

    source
    fn ArchiveStore::append(self : ArchiveStore, sample : TelemetrySample) -> Result[Unit, String]

    ArchiveStore::append_batch

    source
    fn ArchiveStore::append_batch(self : ArchiveStore, samples : Array[TelemetrySample]) -> Int

    ArchiveStore::buckets

    source
    fn ArchiveStore::buckets(self : ArchiveStore, query : ArchiveQuery) -> Array[ArchiveBucket]

    ArchiveStore::evicted

    source
    fn ArchiveStore::evicted(self : ArchiveStore) -> Int

    ArchiveStore::latest

    source
    fn ArchiveStore::latest(self : ArchiveStore, station : CommonAddress, address : InformationAddress) -> ArchivedSample?

    ArchiveStore::len

    source
    fn ArchiveStore::len(self : ArchiveStore) -> Int

    ArchiveStore::new

    source

    ArchiveStore::policy

    source

    ArchiveStore::prune

    source
    fn ArchiveStore::prune(self : ArchiveStore, now : Int) -> Int

    ArchiveStore::query

    source

    ArchiveStore::range_count

    source
    fn ArchiveStore::range_count(self : ArchiveStore, query : ArchiveQuery) -> Int

    ArchivedSample

    source
    pub struct ArchivedSample {
      station : CommonAddress
      address : InformationAddress
      type_id : ApplicationType
      value : Float
      quality : QualityDescriptor
      timestamp : Int
      sequence : Int
      source : String
    } derive(
    Debug    )

    A durable-shaped historical sample retained in memory by the core.

    ArchivedSample::address

    source

    ArchivedSample::quality

    source

    ArchivedSample::sequence

    source
    fn ArchivedSample::sequence(self : ArchivedSample) -> Int

    ArchivedSample::source

    source
    fn ArchivedSample::source(self : ArchivedSample) -> String

    ArchivedSample::station

    source

    ArchivedSample::timestamp

    source
    fn ArchivedSample::timestamp(self : ArchivedSample) -> Int

    ArchivedSample::type_id

    source

    ArchivedSample::value

    source
    fn ArchivedSample::value(self : ArchivedSample) -> Float

    AsduEnvelope

    source
    pub struct AsduEnvelope {
      type_id : ApplicationType
      sequence : Bool
      cause : CauseOfTransmission
      common_address : CommonAddress
      objects : Array[ApplicationObject]
    } derive(Eq, 
    Debug    )

    A complete ASDU envelope with address-qualified application objects.

    AsduEnvelope::cause

    source

    AsduEnvelope::common_address

    source
    fn AsduEnvelope::common_address(self : AsduEnvelope) -> CommonAddress

    AsduEnvelope::count

    source
    fn AsduEnvelope::count(self : AsduEnvelope) -> Int

    AsduEnvelope::new

    source
    fn AsduEnvelope::new(type_id : ApplicationType, sequence : Bool, cause : CauseOfTransmission, common_address : CommonAddress, objects : Array[ApplicationObject]) -> Result[AsduEnvelope, Diagnostic]

    Construct an ASDU envelope and check its object/type relationship.

    AsduEnvelope::objects

    source

    AsduEnvelope::sequence

    source
    fn AsduEnvelope::sequence(self : AsduEnvelope) -> Bool

    AsduEnvelope::type_id

    source

    AsduHeader

    source
    pub struct AsduHeader {
      type_id : TypeId
      variable_count : Int
      sequence : Bool
      cause : Int
      common_address : Int
    } derive(Eq, 
    Debug    )

    Common information object address and cause of transmission.

    AsduHeader::cause

    source
    fn AsduHeader::cause(self : AsduHeader) -> Int

    AsduHeader::common_address

    source
    fn AsduHeader::common_address(self : AsduHeader) -> Int

    AsduHeader::count

    source
    fn AsduHeader::count(self : AsduHeader) -> Int

    AsduHeader::is_sequence

    source
    fn AsduHeader::is_sequence(self : AsduHeader) -> Bool

    AsduHeader::type_id

    source
    fn AsduHeader::type_id(self : AsduHeader) -> TypeId

    AuditAction

    source
    pub enum AuditAction {
      AuthorizationChecked
      PolicyChanged
      MaintenanceChanged
      CommandAuthorized
      FileAuthorized
      StationConfigured
      FailoverAuthorized
    } derive(Eq, 
    Debug    )

    BenchmarkCase

    source
    pub struct BenchmarkCase {
      name : String
      rounds : Int
      payload_size : Int
      target : String
    } derive(Eq, 
    Debug    )

    A repeatable benchmark case with a deterministic workload definition.

    BenchmarkCase::name

    source
    fn BenchmarkCase::name(self : BenchmarkCase) -> String

    BenchmarkCase::new

    source
    fn BenchmarkCase::new(name : String, rounds : Int, payload_size : Int, target : String) -> Result[BenchmarkCase, String]

    BenchmarkCase::payload_size

    source
    fn BenchmarkCase::payload_size(self : BenchmarkCase) -> Int

    BenchmarkCase::rounds

    source
    fn BenchmarkCase::rounds(self : BenchmarkCase) -> Int

    BenchmarkCase::target

    source
    fn BenchmarkCase::target(self : BenchmarkCase) -> String

    BenchmarkResult

    source
    pub struct BenchmarkResult {
      case : BenchmarkCase
      encoded_frames : Int
      encoded_bytes : Int
      checksum : UInt
      elapsed_micros : Int
    } derive(Eq, 
    Debug    )

    BenchmarkResult::case

    source

    BenchmarkResult::checksum

    source
    fn BenchmarkResult::checksum(self : BenchmarkResult) -> UInt

    BenchmarkResult::elapsed_micros

    source
    fn BenchmarkResult::elapsed_micros(self : BenchmarkResult) -> Int

    BenchmarkResult::encoded_bytes

    source
    fn BenchmarkResult::encoded_bytes(self : BenchmarkResult) -> Int

    BenchmarkResult::encoded_frames

    source
    fn BenchmarkResult::encoded_frames(self : BenchmarkResult) -> Int

    BenchmarkResult::frames_per_second

    source
    fn BenchmarkResult::frames_per_second(self : BenchmarkResult) -> Float

    BenchmarkResult::megabytes_per_second

    source
    fn BenchmarkResult::megabytes_per_second(self : BenchmarkResult) -> Float

    BenchmarkResult::new

    source
    fn BenchmarkResult::new(case : BenchmarkCase, workload : BenchmarkWorkload, elapsed_micros : Int) -> Result[BenchmarkResult, String]

    BenchmarkSuite

    source
    pub struct BenchmarkSuite {
      cases : Array[BenchmarkCase]
    } derive(
    Debug    )

    BenchmarkSuite::add

    source
    fn BenchmarkSuite::add(self : BenchmarkSuite, case : BenchmarkCase) -> Result[Unit, String]

    BenchmarkSuite::cases

    source

    BenchmarkSuite::len

    source
    fn BenchmarkSuite::len(self : BenchmarkSuite) -> Int

    BenchmarkSuite::new

    source

    BenchmarkSuite::run

    source
    fn BenchmarkSuite::run(self : BenchmarkSuite, elapsed_micros : Array[Int]) -> Result[Array[BenchmarkResult], String]

    Run a deterministic benchmark workload; elapsed time is supplied by the host.

    BenchmarkWorkload

    source
    pub struct BenchmarkWorkload {
      rounds : Int
      payload_size : Int
      encoded_frames : Int
      encoded_bytes : Int
      checksum : UInt
    } derive(Eq, 
    Debug    )

    A repeatable workload used by local benchmark runs.

    BenchmarkWorkload::checksum

    source
    fn BenchmarkWorkload::checksum(self : BenchmarkWorkload) -> UInt

    BenchmarkWorkload::encoded_bytes

    source
    fn BenchmarkWorkload::encoded_bytes(self : BenchmarkWorkload) -> Int

    BenchmarkWorkload::encoded_frames

    source
    fn BenchmarkWorkload::encoded_frames(self : BenchmarkWorkload) -> Int

    BenchmarkWorkload::payload_size

    source
    fn BenchmarkWorkload::payload_size(self : BenchmarkWorkload) -> Int

    BenchmarkWorkload::rounds

    source
    fn BenchmarkWorkload::rounds(self : BenchmarkWorkload) -> Int

    BinaryCounterValue

    source
    pub struct BinaryCounterValue {
      value : UInt
      sequence : Int
      carry : Bool
      adjusted : Bool
      invalid : Bool
    } derive(Eq, 
    Debug    )

    32-bit binary counter value with sequence and overflow flags.

    BinaryCounterValue::flags

    source
    fn BinaryCounterValue::flags(self : BinaryCounterValue) -> Int

    BinaryCounterValue::new

    source
    fn BinaryCounterValue::new(value : UInt, sequence? : Int, carry? : Bool, adjusted? : Bool, invalid? : Bool) -> Result[BinaryCounterValue, String]

    BinaryCounterValue::sequence

    source
    fn BinaryCounterValue::sequence(self : BinaryCounterValue) -> Int

    BinaryCounterValue::value

    source
    fn BinaryCounterValue::value(self : BinaryCounterValue) -> UInt

    ByteCursor

    source
    pub struct ByteCursor {
      data : Bytes
      offset : Int
    } derive(
    Debug    )

    A bounds-checked cursor for binary protocol decoders.

    ByteCursor::done

    source
    fn ByteCursor::done(self : ByteCursor) -> Bool

    ByteCursor::new

    source
    fn ByteCursor::new(data : Bytes) -> ByteCursor

    ByteCursor::offset

    source
    fn ByteCursor::offset(self : ByteCursor) -> Int

    ByteCursor::read_byte

    source
    fn ByteCursor::read_byte(self : ByteCursor) -> Result[Byte, Diagnostic]

    ByteCursor::read_bytes

    source
    fn ByteCursor::read_bytes(self : ByteCursor, length : Int) -> Result[Bytes, Diagnostic]

    ByteCursor::read_u16

    source
    fn ByteCursor::read_u16(self : ByteCursor) -> Result[Int, Diagnostic]

    ByteCursor::read_u24

    source
    fn ByteCursor::read_u24(self : ByteCursor) -> Result[Int, Diagnostic]

    ByteCursor::read_u32

    source
    fn ByteCursor::read_u32(self : ByteCursor) -> Result[UInt, Diagnostic]

    ByteCursor::remaining

    source
    fn ByteCursor::remaining(self : ByteCursor) -> Int

    ByteCursor::seek

    source
    fn ByteCursor::seek(self : ByteCursor, offset : Int) -> Result[Unit, Diagnostic]

    ByteCursor::skip

    source
    fn ByteCursor::skip(self : ByteCursor, length : Int) -> Result[Unit, Diagnostic]

    ByteStatistics

    source
    pub struct ByteStatistics {
      length : Int
      zeroes : Int
      high_bit : Int
      checksum : UInt
      minimum : Int
      maximum : Int
    } derive(Eq, 
    Debug    )

    Per-byte statistics useful for fixture and link diagnostics.

    ByteStatistics::checksum

    source
    fn ByteStatistics::checksum(self : ByteStatistics) -> UInt

    ByteStatistics::high_bit

    source
    fn ByteStatistics::high_bit(self : ByteStatistics) -> Int

    ByteStatistics::length

    source
    fn ByteStatistics::length(self : ByteStatistics) -> Int

    ByteStatistics::maximum

    source
    fn ByteStatistics::maximum(self : ByteStatistics) -> Int

    ByteStatistics::minimum

    source
    fn ByteStatistics::minimum(self : ByteStatistics) -> Int

    ByteStatistics::zeroes

    source
    fn ByteStatistics::zeroes(self : ByteStatistics) -> Int

    ByteWriter

    source
    pub struct ByteWriter {
      bytes : Array[Byte]
    } derive(
    Debug    )

    A small writer used by application-specific extensions.

    ByteWriter::len

    source
    fn ByteWriter::len(self : ByteWriter) -> Int

    ByteWriter::new

    source
    fn ByteWriter::new() -> ByteWriter

    ByteWriter::push

    source
    fn ByteWriter::push(self : ByteWriter, value : Byte) -> Unit

    ByteWriter::push_bytes

    source
    fn ByteWriter::push_bytes(self : ByteWriter, value : Bytes) -> Unit

    ByteWriter::push_u16

    source
    fn ByteWriter::push_u16(self : ByteWriter, value : Int) -> Result[Unit, String]

    ByteWriter::push_u24

    source
    fn ByteWriter::push_u24(self : ByteWriter, value : Int) -> Result[Unit, String]

    ByteWriter::push_u32

    source
    fn ByteWriter::push_u32(self : ByteWriter, value : UInt) -> Unit

    ByteWriter::to_bytes

    source
    fn ByteWriter::to_bytes(self : ByteWriter) -> Bytes

    Cause

    source
    pub enum Cause {
      Periodic
      Background
      Spontaneous
      Initialised
      Request
      Activation
      ActivationConfirmation
      ActivationTermination
      Unknown(Int)
    } derive(Eq, 
    Debug    )

    Standard causes of transmission used by IEC 104 application services.

    Cause::is_activation

    source
    fn Cause::is_activation(self : Cause) -> Bool

    Cause::is_spontaneous

    source
    fn Cause::is_spontaneous(self : Cause) -> Bool

    Cause::is_termination

    source
    fn Cause::is_termination(self : Cause) -> Bool

    Cause::number

    source
    fn Cause::number(self : Cause) -> Int

    CauseCategory

    source
    pub enum CauseCategory {
      Periodic
      Background
      Spontaneous
      Initialised
      Request
      Activation
      ActivationConfirmation
      ActivationTermination
      ReturnInformationRemote
      ReturnInformationLocal
      UnknownCause
    } derive(Eq, 
    Debug    )

    Cause of transmission category. The numeric value is kept separate from the qualifier so applications can preserve vendor extensions.

    CauseCategory::number

    source
    fn CauseCategory::number(self : CauseCategory) -> Int

    Return the standard six-bit cause value.

    CauseOfTransmission

    source
    pub struct CauseOfTransmission {
      category : CauseCategory
      number : Int
      positive : Bool
      test_flag : Bool
      originator : Int
      qualifier : Int
    } derive(Eq, 
    Debug    )

    Full cause of transmission, including the originator and qualifier bits.

    CauseOfTransmission::flags

    source
    fn CauseOfTransmission::flags(self : CauseOfTransmission) -> Int

    Return the four low flag bits in the IEC COT representation.

    CauseOfTransmission::from_number

    source
    fn CauseOfTransmission::from_number(number : Int, positive? : Bool, test_flag? : Bool, originator? : Int, qualifier? : Int) -> Result[CauseOfTransmission, String]

    Construct a cause from a raw standard number while preserving extension data.

    CauseOfTransmission::new

    source
    fn CauseOfTransmission::new(category : CauseCategory, positive? : Bool, test_flag? : Bool, originator? : Int, qualifier? : Int) -> Result[CauseOfTransmission, String]

    Construct a validated cause of transmission.

    CauseOfTransmission::originator

    source
    fn CauseOfTransmission::originator(self : CauseOfTransmission) -> Int

    Return the originator address.

    CauseOfTransmission::qualifier

    source
    fn CauseOfTransmission::qualifier(self : CauseOfTransmission) -> Int

    Return the qualifier value.

    CauseOfTransmission::raw

    source

    Return the raw cause number.

    ClockSyncTransaction

    source
    pub struct ClockSyncTransaction {
      request : ServiceRequest
      status : ServiceStatus
      received : Cp56Time?
      applied_at : Int?
    } derive(
    Debug    )

    Clock synchronization service with a deterministic skew calculation.

    ClockSyncTransaction::activate

    source
    fn ClockSyncTransaction::activate(self : ClockSyncTransaction) -> Result[Unit, String]

    ClockSyncTransaction::apply

    source
    fn ClockSyncTransaction::apply(self : ClockSyncTransaction, timestamp : Cp56Time, applied_at : Int) -> Result[Int, String]

    ClockSyncTransaction::new

    source
    fn ClockSyncTransaction::new(request : ServiceRequest) -> Result[ClockSyncTransaction, String]

    ClockSyncTransaction::received

    source

    ClockSyncTransaction::status

    source

    CommandAudit

    source
    pub struct CommandAudit {
      ticket : Int
      timestamp : Int
      from : CommandLifecycle
      to : CommandLifecycle
      attempt : Int
      message : String
    } derive(Eq, 
    Debug    )

    A transition emitted by the scheduler for audit and UI consumers.

    CommandAudit::attempt

    source
    fn CommandAudit::attempt(self : CommandAudit) -> Int

    CommandAudit::from

    source

    CommandAudit::message

    source
    fn CommandAudit::message(self : CommandAudit) -> String

    CommandAudit::new

    source
    fn CommandAudit::new(ticket : Int, timestamp : Int, from : CommandLifecycle, to : CommandLifecycle, attempt : Int, message : String) -> CommandAudit

    CommandAudit::ticket

    source
    fn CommandAudit::ticket(self : CommandAudit) -> Int

    CommandAudit::timestamp

    source
    fn CommandAudit::timestamp(self : CommandAudit) -> Int

    CommandAudit::to

    source

    CommandDispatch

    source
    pub struct CommandDispatch {
      ticket : Int
      station : CommonAddress
      object : ApplicationObject
      attempt : Int
      expires_at : Int
    } derive(
    Debug    )

    A dispatch result containing the ticket and object to encode on the wire.

    CommandDispatch::attempt

    source
    fn CommandDispatch::attempt(self : CommandDispatch) -> Int

    CommandDispatch::expires_at

    source
    fn CommandDispatch::expires_at(self : CommandDispatch) -> Int

    CommandDispatch::object

    source

    CommandDispatch::station

    source

    CommandDispatch::ticket

    source
    fn CommandDispatch::ticket(self : CommandDispatch) -> Int

    CommandLifecycle

    source
    pub enum CommandLifecycle {
      QueuedCommand
      DispatchedCommand
      AwaitingConfirmation
      CompletedCommand
      FailedCommand
      RejectedCommand
      ExpiredCommand
      CancelledCommand
    } derive(Eq, 
    Debug    )

    Lifecycle state of a command ticket.

    CommandOutcome

    source
    pub struct CommandOutcome {
      accepted : Bool
      status : ServiceStatus
      object : ApplicationObject?
      message : String
    } derive(
    Debug    )

    CommandOutcome::accepted

    source
    fn CommandOutcome::accepted(self : CommandOutcome) -> Bool

    CommandOutcome::message

    source
    fn CommandOutcome::message(self : CommandOutcome) -> String

    CommandOutcome::object

    source

    CommandOutcome::status

    source

    CommandPolicy

    source
    pub struct CommandPolicy {
      allowed : Map[Int, Bool]
      allow_all : Bool
      max_qualifier : Int
    } derive(
    Debug    )

    A command authorization policy for host applications.

    CommandPolicy::allow

    source
    fn CommandPolicy::allow(self : CommandPolicy, address : InformationAddress) -> Unit

    CommandPolicy::allow_all

    source
    fn CommandPolicy::allow_all() -> CommandPolicy

    CommandPolicy::deny

    source
    fn CommandPolicy::deny(self : CommandPolicy, address : InformationAddress) -> Unit

    CommandPolicy::deny_all

    source
    fn CommandPolicy::deny_all() -> CommandPolicy

    CommandPolicy::permits

    source
    fn CommandPolicy::permits(self : CommandPolicy, object : ApplicationObject) -> Bool

    CommandPolicy::set_max_qualifier

    source
    fn CommandPolicy::set_max_qualifier(self : CommandPolicy, value : Int) -> Result[Unit, String]

    CommandPriority

    source
    pub enum CommandPriority {
      EmergencyPriority
      HighPriority
      NormalPriority
      LowPriority
    } derive(Eq, 
    Debug    )

    Priority used by the deterministic command scheduler.

    CommandPriority::weight

    source
    fn CommandPriority::weight(self : CommandPriority) -> Int

    CommandQueue

    source
    pub struct CommandQueue {
      pending : Array[ApplicationObject]
      completed : Array[CommandOutcome]
      limit : Int
    } derive(
    Debug    )

    A FIFO command queue with explicit outcomes.

    CommandQueue::completed_count

    source
    fn CommandQueue::completed_count(self : CommandQueue) -> Int

    CommandQueue::enqueue

    source
    fn CommandQueue::enqueue(self : CommandQueue, object : ApplicationObject) -> Result[Unit, String]

    CommandQueue::new

    source
    fn CommandQueue::new(limit? : Int) -> Result[CommandQueue, String]

    CommandQueue::outcomes

    source

    CommandQueue::pending_count

    source
    fn CommandQueue::pending_count(self : CommandQueue) -> Int

    CommandQueue::process_one

    source
    fn CommandQueue::process_one(self : CommandQueue, policy : CommandPolicy) -> CommandOutcome?

    CommandRequest

    source
    pub struct CommandRequest {
      ticket : Int
      station : CommonAddress
      object : ApplicationObject
      priority : CommandPriority
      submitted_at : Int
      deadline : Int
      idempotency_key : String
      source : String
      policy : RetryPolicy
      attempts : Int
      lifecycle : CommandLifecycle
      next_attempt_at : Int
      last_error : String
    } derive(
    Debug    )

    A command request admitted to the scheduler.

    CommandRequest::attempts

    source
    fn CommandRequest::attempts(self : CommandRequest) -> Int

    CommandRequest::deadline

    source
    fn CommandRequest::deadline(self : CommandRequest) -> Int

    CommandRequest::idempotency_key

    source
    fn CommandRequest::idempotency_key(self : CommandRequest) -> String

    CommandRequest::last_error

    source
    fn CommandRequest::last_error(self : CommandRequest) -> String

    CommandRequest::lifecycle

    source

    CommandRequest::new

    source
    fn CommandRequest::new(ticket : Int, station : CommonAddress, object : ApplicationObject, priority : CommandPriority, submitted_at : Int, deadline : Int, idempotency_key : String, source : String, policy : RetryPolicy) -> Result[CommandRequest, Diagnostic]

    CommandRequest::next_attempt_at

    source
    fn CommandRequest::next_attempt_at(self : CommandRequest) -> Int

    CommandRequest::object

    source

    CommandRequest::policy

    source

    CommandRequest::priority

    source

    CommandRequest::source

    source
    fn CommandRequest::source(self : CommandRequest) -> String

    CommandRequest::station

    source

    CommandRequest::submitted_at

    source
    fn CommandRequest::submitted_at(self : CommandRequest) -> Int

    CommandRequest::ticket

    source
    fn CommandRequest::ticket(self : CommandRequest) -> Int

    CommandScheduler

    source
    pub struct CommandScheduler {
      pending : Array[CommandRequest]
      audits : Array[CommandAudit]
      audit_limit : Int
      idempotency : Map[String, Int]
      next_ticket : Int
      metrics : SchedulerMetrics
    } derive(
    Debug    )

    Deterministic command scheduler with idempotency and retry handling.

    CommandScheduler::audits

    source

    CommandScheduler::cancel

    source
    fn CommandScheduler::cancel(self : CommandScheduler, ticket : Int, now : Int, reason? : String) -> Result[CommandRequest, Diagnostic]

    CommandScheduler::confirm

    source
    fn CommandScheduler::confirm(self : CommandScheduler, ticket : Int, now : Int, accepted : Bool, message? : String) -> Result[CommandRequest, Diagnostic]

    CommandScheduler::dispatch

    source
    fn CommandScheduler::dispatch(self : CommandScheduler, policy : CommandPolicy, now : Int) -> Result[CommandDispatch?, Diagnostic]

    CommandScheduler::expire

    source
    fn CommandScheduler::expire(self : CommandScheduler, now : Int) -> Array[CommandRequest]

    CommandScheduler::get

    source
    fn CommandScheduler::get(self : CommandScheduler, ticket : Int) -> CommandRequest?

    CommandScheduler::metrics

    source

    CommandScheduler::new

    source
    fn CommandScheduler::new(audit_limit? : Int) -> Result[CommandScheduler, String]

    CommandScheduler::pending_count

    source
    fn CommandScheduler::pending_count(self : CommandScheduler) -> Int

    CommandScheduler::submit

    source
    fn CommandScheduler::submit(self : CommandScheduler, station : CommonAddress, object : ApplicationObject, priority : CommandPriority, now : Int, deadline : Int, idempotency_key : String, source? : String, policy? : RetryPolicy) -> Result[CommandRequest, Diagnostic]

    CommandScheduler::terminal

    source

    CommonAddress

    source
    pub struct CommonAddress {
      value : Int
    } derive(Eq, 
    Debug    )

    Common address of ASDU values. Zero is reserved for an unassigned station.

    CommonAddress::is_global

    source
    fn CommonAddress::is_global(self : CommonAddress) -> Bool

    Return whether this common address is the global station address.

    CommonAddress::new

    source
    fn CommonAddress::new(value : Int) -> Result[CommonAddress, String]

    Create a two-byte common address.

    CommonAddress::number

    source
    fn CommonAddress::number(self : CommonAddress) -> Int

    Return the numeric common address.

    ConfigChange

    source
    pub struct ConfigChange {
      key : String
      kind : ConfigChangeKind
      from : ConfigValue?
      to : ConfigValue?
      revision : Int
      timestamp : Int
      operator : String
      message : String
    } derive(Eq, 
    Debug    )

    ConfigChange::from

    source

    ConfigChange::key

    source
    fn ConfigChange::key(self : ConfigChange) -> String

    ConfigChange::kind

    source

    ConfigChange::message

    source
    fn ConfigChange::message(self : ConfigChange) -> String

    ConfigChange::operator

    source
    fn ConfigChange::operator(self : ConfigChange) -> String

    ConfigChange::revision

    source
    fn ConfigChange::revision(self : ConfigChange) -> Int

    ConfigChange::timestamp

    source
    fn ConfigChange::timestamp(self : ConfigChange) -> Int

    ConfigChange::to

    source

    ConfigChangeKind

    source
    pub enum ConfigChangeKind {
      ConfigAdded
      ConfigUpdated
      ConfigReset
      ConfigRejected
    } derive(Eq, 
    Debug    )

    ConfigDefinition

    source
    pub struct ConfigDefinition {
      key : String
      description : String
      default_value : ConfigValue
      required : Bool
      minimum : Int?
      maximum : Int?
      secret : Bool
      restart_required : Bool
    } derive(Eq, 
    Debug    )

    ConfigDefinition::default_value

    source
    fn ConfigDefinition::default_value(self : ConfigDefinition) -> ConfigValue

    ConfigDefinition::description

    source
    fn ConfigDefinition::description(self : ConfigDefinition) -> String

    ConfigDefinition::key

    source
    fn ConfigDefinition::key(self : ConfigDefinition) -> String

    ConfigDefinition::maximum

    source
    fn ConfigDefinition::maximum(self : ConfigDefinition) -> Int?

    ConfigDefinition::minimum

    source
    fn ConfigDefinition::minimum(self : ConfigDefinition) -> Int?

    ConfigDefinition::new

    source
    fn ConfigDefinition::new(key : String, description : String, default_value : ConfigValue, required? : Bool, minimum? : Int, maximum? : Int, secret? : Bool, restart_required? : Bool) -> Result[ConfigDefinition, String]

    ConfigDefinition::required

    source
    fn ConfigDefinition::required(self : ConfigDefinition) -> Bool

    ConfigDefinition::restart_required

    source
    fn ConfigDefinition::restart_required(self : ConfigDefinition) -> Bool

    ConfigDefinition::secret

    source
    fn ConfigDefinition::secret(self : ConfigDefinition) -> Bool

    ConfigEntry

    source
    pub struct ConfigEntry {
      definition : ConfigDefinition
      value : ConfigValue
      revision : Int
      updated_at : Int
      updated_by : String
    } derive(Eq, 
    Debug    )

    Value and source revision stored for one key.

    ConfigEntry::definition

    source
    fn ConfigEntry::definition(self : ConfigEntry) -> ConfigDefinition

    ConfigEntry::revision

    source
    fn ConfigEntry::revision(self : ConfigEntry) -> Int

    ConfigEntry::updated_at

    source
    fn ConfigEntry::updated_at(self : ConfigEntry) -> Int

    ConfigEntry::updated_by

    source
    fn ConfigEntry::updated_by(self : ConfigEntry) -> String

    ConfigEntry::value

    source
    fn ConfigEntry::value(self : ConfigEntry) -> ConfigValue

    ConfigTransaction

    source
    pub struct ConfigTransaction {
      base_revision : Int
      operator : String
      timestamp : Int
      updates : Array[(String, ConfigValue)]
      resets : Array[String]
      closed : Bool
    } derive(
    Debug    )

    ConfigTransaction::base_revision

    source
    fn ConfigTransaction::base_revision(self : ConfigTransaction) -> Int

    ConfigTransaction::count

    source
    fn ConfigTransaction::count(self : ConfigTransaction) -> Int

    ConfigTransaction::new

    source
    fn ConfigTransaction::new(base_revision : Int, operator : String, timestamp : Int) -> ConfigTransaction

    ConfigTransaction::operator

    source
    fn ConfigTransaction::operator(self : ConfigTransaction) -> String

    ConfigTransaction::reset

    source
    fn ConfigTransaction::reset(self : ConfigTransaction, key : String) -> Result[Unit, String]

    ConfigTransaction::rollback

    source
    fn ConfigTransaction::rollback(self : ConfigTransaction) -> Unit

    ConfigTransaction::set

    source
    fn ConfigTransaction::set(self : ConfigTransaction, key : String, value : ConfigValue) -> Result[Unit, String]

    ConfigTransaction::timestamp

    source
    fn ConfigTransaction::timestamp(self : ConfigTransaction) -> Int

    ConfigValue

    source
    pub enum ConfigValue {
      ConfigInt(Int)
      ConfigBool(Bool)
      ConfigText(String)
      ConfigDuration(Int)
      ConfigAddress(CommonAddress)
      ConfigAddressList(Array[CommonAddress])
    } derive(Eq, 
    Debug    )

    Configuration value types accepted by the runtime registry.

    ConfigValue::type_name

    source
    fn ConfigValue::type_name(self : ConfigValue) -> String

    ConfigurationRegistry

    source
    pub struct ConfigurationRegistry {
      definitions : Map[String, ConfigDefinition]
      values : Map[String, ConfigEntry]
      history : Array[ConfigChange]
      history_limit : Int
      revision : Int
    } derive(
    Debug    )

    Versioned configuration registry with atomic transaction commits.

    ConfigurationRegistry::commit

    source
    fn ConfigurationRegistry::commit(self : ConfigurationRegistry, transaction : ConfigTransaction) -> Result[Array[ConfigChange], String]

    ConfigurationRegistry::definition

    source
    fn ConfigurationRegistry::definition(self : ConfigurationRegistry, key : String) -> ConfigDefinition?

    ConfigurationRegistry::export_lines

    source
    fn ConfigurationRegistry::export_lines(self : ConfigurationRegistry) -> Array[String]

    ConfigurationRegistry::get

    source
    fn ConfigurationRegistry::get(self : ConfigurationRegistry, key : String) -> ConfigEntry?

    ConfigurationRegistry::history

    source

    ConfigurationRegistry::keys

    source

    ConfigurationRegistry::len

    source

    ConfigurationRegistry::new

    source
    fn ConfigurationRegistry::new(history_limit? : Int) -> Result[ConfigurationRegistry, String]

    ConfigurationRegistry::register_definition

    source
    fn ConfigurationRegistry::register_definition(self : ConfigurationRegistry, definition : ConfigDefinition, timestamp : Int, operator : String) -> Result[Unit, String]

    ConfigurationRegistry::reset

    source
    fn ConfigurationRegistry::reset(self : ConfigurationRegistry, key : String, timestamp : Int, operator : String) -> Result[ConfigEntry, String]

    ConfigurationRegistry::revision

    source
    fn ConfigurationRegistry::revision(self : ConfigurationRegistry) -> Int

    ConfigurationRegistry::set

    source
    fn ConfigurationRegistry::set(self : ConfigurationRegistry, key : String, value : ConfigValue, timestamp : Int, operator : String) -> Result[ConfigEntry, String]

    ConformanceReport

    source
    pub struct ConformanceReport {
      valid : Bool
      type_id : ApplicationType
      object_count : Int
      expected_width : Int
      actual_width : Int
      issues : Array[String]
    } derive(Eq, 
    Debug    )

    An ASDU consistency report that can be shown in CLI diagnostics.

    ConformanceReport::actual_width

    source
    fn ConformanceReport::actual_width(self : ConformanceReport) -> Int

    ConformanceReport::add_issue

    source
    fn ConformanceReport::add_issue(self : ConformanceReport, message : String) -> Unit

    ConformanceReport::expected_width

    source
    fn ConformanceReport::expected_width(self : ConformanceReport) -> Int

    ConformanceReport::issues

    source
    fn ConformanceReport::issues(self : ConformanceReport) -> Array[String]

    ConformanceReport::new

    source

    ConformanceReport::object_count

    source
    fn ConformanceReport::object_count(self : ConformanceReport) -> Int

    ConformanceReport::type_id

    source

    ConformanceReport::valid

    source
    fn ConformanceReport::valid(self : ConformanceReport) -> Bool

    ConformanceVector

    source
    pub struct ConformanceVector {
      name : String
      category : VectorCategory
      input : Bytes
      expectation : VectorExpectation
      expected_kind : FrameKind?
      expected_send : Int?
      expected_receive : Int?
      expected_payload : Bytes?
    } derive(
    Debug    )

    A deterministic byte-level protocol vector.

    ConformanceVector::category

    source

    ConformanceVector::expectation

    source

    ConformanceVector::expected_kind

    source
    fn ConformanceVector::expected_kind(self : ConformanceVector) -> FrameKind?

    ConformanceVector::expected_payload

    source
    fn ConformanceVector::expected_payload(self : ConformanceVector) -> Bytes?

    ConformanceVector::expected_receive

    source
    fn ConformanceVector::expected_receive(self : ConformanceVector) -> Int?

    ConformanceVector::expected_send

    source
    fn ConformanceVector::expected_send(self : ConformanceVector) -> Int?

    ConformanceVector::input

    source
    fn ConformanceVector::input(self : ConformanceVector) -> Bytes

    ConformanceVector::name

    source
    fn ConformanceVector::name(self : ConformanceVector) -> String

    ConformanceVector::new

    source
    fn ConformanceVector::new(name : String, category : VectorCategory, input : Bytes, expectation : VectorExpectation, expected_kind? : FrameKind, expected_send? : Int, expected_receive? : Int, expected_payload? : Bytes) -> Result[ConformanceVector, String]

    ConnectionParameters

    source
    pub struct ConnectionParameters {
      k : Int
      w : Int
      t0_seconds : Int
      t1_seconds : Int
      t2_seconds : Int
      t3_seconds : Int
    } derive(Eq, 
    Debug    )

    IEC 104 link-layer timing and window parameters.

    ConnectionParameters::default

    source

    Default parameters from the commonly deployed IEC 104 profile.

    ConnectionParameters::k

    source

    ConnectionParameters::new

    source
    fn ConnectionParameters::new(k : Int, w : Int, t0_seconds : Int, t1_seconds : Int, t2_seconds : Int, t3_seconds : Int) -> Result[ConnectionParameters, String]

    Validate and construct link-layer parameters.

    ConnectionParameters::t0

    source

    ConnectionParameters::t1

    source

    ConnectionParameters::t2

    source

    ConnectionParameters::t3

    source

    ConnectionParameters::w

    source

    CounterInterrogationRequest

    source
    pub struct CounterInterrogationRequest {
      common_address : CommonAddress
      qualifier : Int
      created_at : Int
    } derive(Eq, 
    Debug    )

    Counter-interrogation request used for historical counter snapshots.

    CounterInterrogationRequest::common_address

    source

    CounterInterrogationRequest::created_at

    source

    CounterInterrogationRequest::new

    source
    fn CounterInterrogationRequest::new(common_address : CommonAddress, qualifier : Int, created_at : Int) -> Result[CounterInterrogationRequest, String]

    CounterInterrogationRequest::qualifier

    source

    Cp24Time

    source
    pub struct Cp24Time {
      millisecond : Int
      minute : Int
    } derive(Eq, 
    Debug    )

    Three-byte CP24Time2a value used by short time-tagged ASDUs.

    Cp24Time::from_bytes

    source
    fn Cp24Time::from_bytes(data : Bytes, offset? : Int) -> Result[Cp24Time, String]

    Cp24Time::millisecond

    source
    fn Cp24Time::millisecond(self : Cp24Time) -> Int

    Cp24Time::minute

    source
    fn Cp24Time::minute(self : Cp24Time) -> Int

    Cp24Time::new

    source
    fn Cp24Time::new(millisecond : Int, minute : Int) -> Result[Cp24Time, String]

    Cp24Time::remainder_millisecond

    source
    fn Cp24Time::remainder_millisecond(self : Cp24Time) -> Int

    Cp24Time::second

    source
    fn Cp24Time::second(self : Cp24Time) -> Int

    Cp24Time::to_array

    source
    fn Cp24Time::to_array(self : Cp24Time) -> Array[Byte]

    Cp56Time

    source
    pub struct Cp56Time {
      year : Int
      month : Int
      day : Int
      weekday : Int
      hour : Int
      minute : Int
      millisecond : Int
    } derive(Eq, 
    Debug    )

    Seven-byte CP56Time2a timestamp.

    Cp56Time::calendar_year

    source
    fn Cp56Time::calendar_year(self : Cp56Time, century? : Int) -> Int

    Return the four-digit calendar year represented by the protocol year.

    Cp56Time::day

    source
    fn Cp56Time::day(self : Cp56Time) -> Int

    Cp56Time::from_bytes

    source
    fn Cp56Time::from_bytes(data : Bytes, offset? : Int) -> Result[Cp56Time, String]

    Cp56Time::hour

    source
    fn Cp56Time::hour(self : Cp56Time) -> Int

    Cp56Time::millisecond

    source
    fn Cp56Time::millisecond(self : Cp56Time) -> Int

    Cp56Time::minute

    source
    fn Cp56Time::minute(self : Cp56Time) -> Int

    Cp56Time::month

    source
    fn Cp56Time::month(self : Cp56Time) -> Int

    Cp56Time::new

    source
    fn Cp56Time::new(year : Int, month : Int, day : Int, hour : Int, minute : Int, millisecond : Int, weekday? : Int) -> Result[Cp56Time, String]

    Construct a CP56 timestamp. The year is the two-digit protocol year.

    Cp56Time::ordering_key

    source
    fn Cp56Time::ordering_key(self : Cp56Time) -> Int

    A deterministic date-time ordering key.

    Cp56Time::remainder_millisecond

    source
    fn Cp56Time::remainder_millisecond(self : Cp56Time) -> Int

    Cp56Time::second

    source
    fn Cp56Time::second(self : Cp56Time) -> Int

    Cp56Time::to_array

    source
    fn Cp56Time::to_array(self : Cp56Time) -> Array[Byte]

    Cp56Time::weekday

    source
    fn Cp56Time::weekday(self : Cp56Time) -> Int

    Cp56Time::year

    source
    fn Cp56Time::year(self : Cp56Time) -> Int

    DatabaseEvent

    source
    pub struct DatabaseEvent {
      sequence : Int
      timestamp : Int
      kind : DatabaseEventKind
      common_address : CommonAddress?
      point_address : InformationAddress?
      message : String
    } derive(Eq, 
    Debug    )

    DatabaseEvent::common_address

    source
    fn DatabaseEvent::common_address(self : DatabaseEvent) -> CommonAddress?

    DatabaseEvent::kind

    source

    DatabaseEvent::message

    source
    fn DatabaseEvent::message(self : DatabaseEvent) -> String

    DatabaseEvent::new

    source
    fn DatabaseEvent::new(sequence : Int, timestamp : Int, kind : DatabaseEventKind, common_address? : CommonAddress, point_address? : InformationAddress, message? : String) -> DatabaseEvent

    DatabaseEvent::point_address

    source
    fn DatabaseEvent::point_address(self : DatabaseEvent) -> InformationAddress?

    DatabaseEvent::sequence

    source
    fn DatabaseEvent::sequence(self : DatabaseEvent) -> Int

    DatabaseEvent::timestamp

    source
    fn DatabaseEvent::timestamp(self : DatabaseEvent) -> Int

    DatabaseEventKind

    source
    pub enum DatabaseEventKind {
      StationAdded
      StationRemoved
      StationStateChanged
      PointChanged
      DatabaseCompacted
      TransactionCommitted
      TransactionRejected
    } derive(Eq, 
    Debug    )

    A bounded journal entry for changes to the station database.

    DatabaseSnapshot

    source
    pub struct DatabaseSnapshot {
      revision : Int
      timestamp : Int
      stations : Array[StationSummary]
      events : Array[DatabaseEvent]
    } derive(
    Debug    )

    A database snapshot used by exports and optimistic readers.

    DatabaseSnapshot::events

    source

    DatabaseSnapshot::revision

    source
    fn DatabaseSnapshot::revision(self : DatabaseSnapshot) -> Int

    DatabaseSnapshot::stations

    source

    DatabaseSnapshot::timestamp

    source
    fn DatabaseSnapshot::timestamp(self : DatabaseSnapshot) -> Int

    DatabaseTransaction

    source
    pub struct DatabaseTransaction {
      base_revision : Int
      timestamp : Int
      additions : Array[StationConfig]
      removals : Array[CommonAddress]
      states : Array[(CommonAddress, StationStatus, StationStateReason, String)]
      points : Array[(CommonAddress, ApplicationObject, String)]
      closed : Bool
    } derive(
    Debug    )

    A transaction over station configuration and point updates.

    DatabaseTransaction::add_station

    source
    fn DatabaseTransaction::add_station(self : DatabaseTransaction, config : StationConfig) -> Result[Unit, String]

    DatabaseTransaction::base_revision

    source
    fn DatabaseTransaction::base_revision(self : DatabaseTransaction) -> Int

    DatabaseTransaction::new

    source
    fn DatabaseTransaction::new(base_revision : Int, timestamp : Int) -> DatabaseTransaction

    DatabaseTransaction::operation_count

    source
    fn DatabaseTransaction::operation_count(self : DatabaseTransaction) -> Int

    DatabaseTransaction::remove_station

    source
    fn DatabaseTransaction::remove_station(self : DatabaseTransaction, common_address : CommonAddress) -> Result[Unit, String]

    DatabaseTransaction::rollback

    source
    fn DatabaseTransaction::rollback(self : DatabaseTransaction) -> Unit

    DatabaseTransaction::set_state

    source
    fn DatabaseTransaction::set_state(self : DatabaseTransaction, common_address : CommonAddress, status : StationStatus, reason : StationStateReason, message? : String) -> Result[Unit, String]

    DatabaseTransaction::timestamp

    source
    fn DatabaseTransaction::timestamp(self : DatabaseTransaction) -> Int

    DatabaseTransaction::write_point

    source
    fn DatabaseTransaction::write_point(self : DatabaseTransaction, common_address : CommonAddress, object : ApplicationObject, source? : String) -> Result[Unit, Diagnostic]

    DeadbandRule

    source
    pub struct DeadbandRule {
      absolute : Float
      relative_percent : Float
      minimum_interval : Int
    } derive(Eq, 
    Debug    )

    Deadband rule that prevents unchanged analog values from flooding a link.

    DeadbandRule::absolute

    source
    fn DeadbandRule::absolute(self : DeadbandRule) -> Float

    DeadbandRule::changed

    source
    fn DeadbandRule::changed(self : DeadbandRule, previous : TelemetrySample, current : TelemetrySample) -> Bool

    DeadbandRule::minimum_interval

    source
    fn DeadbandRule::minimum_interval(self : DeadbandRule) -> Int

    DeadbandRule::new

    source
    fn DeadbandRule::new(absolute? : Float, relative_percent? : Float, minimum_interval? : Int) -> Result[DeadbandRule, String]

    DeadbandRule::relative_percent

    source
    fn DeadbandRule::relative_percent(self : DeadbandRule) -> Float

    Diagnostic

    source
    pub struct Diagnostic {
      kind : DiagnosticKind
      message : String
      offset : Int?
    } derive(Eq, 
    Debug    )

    Structured diagnostic returned by validation and service layers.

    Diagnostic::kind

    source

    Diagnostic::message

    source
    fn Diagnostic::message(self : Diagnostic) -> String

    Diagnostic::new

    source
    fn Diagnostic::new(kind : DiagnosticKind, message : String, offset? : Int) -> Diagnostic

    Diagnostic::offset

    source
    fn Diagnostic::offset(self : Diagnostic) -> Int?

    Diagnostic::to_line

    source
    fn Diagnostic::to_line(self : Diagnostic) -> String

    Produce a compact human-readable diagnostic line for CLI and logs.

    DiagnosticCatalog

    source
    pub struct DiagnosticCatalog {
      records : Map[String, DiagnosticRecord]
      history : Array[DiagnosticRecord]
      history_limit : Int
      metrics : DiagnosticCatalogMetrics
    } derive(
    Debug    )

    DiagnosticCatalog::acknowledge

    source
    fn DiagnosticCatalog::acknowledge(self : DiagnosticCatalog, key : String, operator : String) -> Result[DiagnosticRecord, String]

    DiagnosticCatalog::active

    source

    DiagnosticCatalog::get

    source
    fn DiagnosticCatalog::get(self : DiagnosticCatalog, key : String) -> DiagnosticRecord?

    DiagnosticCatalog::history

    source

    DiagnosticCatalog::len

    source
    fn DiagnosticCatalog::len(self : DiagnosticCatalog) -> Int

    DiagnosticCatalog::metrics

    source

    DiagnosticCatalog::new

    source
    fn DiagnosticCatalog::new(history_limit? : Int) -> Result[DiagnosticCatalog, String]

    DiagnosticCatalog::purge_resolved

    source
    fn DiagnosticCatalog::purge_resolved(self : DiagnosticCatalog) -> Int

    DiagnosticCatalog::record_diagnostic

    source
    fn DiagnosticCatalog::record_diagnostic(self : DiagnosticCatalog, diagnostic : Diagnostic, severity : DiagnosticSeverity, station : CommonAddress?, timestamp : Int) -> DiagnosticRecord

    DiagnosticCatalog::resolve

    source
    fn DiagnosticCatalog::resolve(self : DiagnosticCatalog, key : String, timestamp : Int) -> Result[DiagnosticRecord, String]

    DiagnosticCatalogMetrics

    source
    pub struct DiagnosticCatalogMetrics {
      raised : Int
      resolved : Int
      acknowledged : Int
      deduplicated : Int
    } derive(Eq, 
    Debug    )

    DiagnosticCatalogMetrics::acknowledged

    source
    fn DiagnosticCatalogMetrics::acknowledged(self : DiagnosticCatalogMetrics) -> Int

    DiagnosticCatalogMetrics::deduplicated

    source
    fn DiagnosticCatalogMetrics::deduplicated(self : DiagnosticCatalogMetrics) -> Int

    DiagnosticCatalogMetrics::new

    source

    DiagnosticCatalogMetrics::raised

    source

    DiagnosticCatalogMetrics::resolved

    source

    DiagnosticKind

    source
    pub enum DiagnosticKind {
      MalformedFrame
      InvalidSequence
      InvalidAddress
      InvalidType
      InvalidQualifier
      UnsupportedFeature
      WindowExhausted
      TimerExpired
      StateViolation
      TransportFailure
    } derive(Eq, 
    Debug    )

    A stable classification for protocol diagnostics.

    DiagnosticRecord

    source
    pub struct DiagnosticRecord {
      key : String
      kind : DiagnosticKind
      severity : DiagnosticSeverity
      message : String
      station : CommonAddress?
      first_seen : Int
      last_seen : Int
      occurrences : Int
      active : Bool
      acknowledged : Bool
      acknowledged_by : String?
    } derive(Eq, 
    Debug    )

    DiagnosticRecord::acknowledged

    source
    fn DiagnosticRecord::acknowledged(self : DiagnosticRecord) -> Bool

    DiagnosticRecord::acknowledged_by

    source
    fn DiagnosticRecord::acknowledged_by(self : DiagnosticRecord) -> String?

    DiagnosticRecord::active

    source
    fn DiagnosticRecord::active(self : DiagnosticRecord) -> Bool

    DiagnosticRecord::first_seen

    source
    fn DiagnosticRecord::first_seen(self : DiagnosticRecord) -> Int

    DiagnosticRecord::key

    source
    fn DiagnosticRecord::key(self : DiagnosticRecord) -> String

    DiagnosticRecord::kind

    source

    DiagnosticRecord::last_seen

    source
    fn DiagnosticRecord::last_seen(self : DiagnosticRecord) -> Int

    DiagnosticRecord::message

    source
    fn DiagnosticRecord::message(self : DiagnosticRecord) -> String

    DiagnosticRecord::occurrences

    source
    fn DiagnosticRecord::occurrences(self : DiagnosticRecord) -> Int

    DiagnosticRecord::severity

    source

    DiagnosticRecord::station

    source

    DiagnosticSeverity

    source
    pub enum DiagnosticSeverity {
      NoticeDiagnostic
      WarningDiagnostic
      ErrorDiagnostic
      CriticalDiagnostic
    } derive(Eq, 
    Debug    )

    Operational severity for normalized protocol diagnostics.

    DiagnosticSeverity::weight

    source
    fn DiagnosticSeverity::weight(self : DiagnosticSeverity) -> Int

    DoublePointValue

    source
    pub struct DoublePointValue {
      state : Int
      quality : StatusQuality
    } derive(Eq, 
    Debug    )

    Double point information value. IEC 104 reserves state value 0 and 3.

    DoublePointValue::from_byte

    source
    fn DoublePointValue::from_byte(value : Int) -> Result[DoublePointValue, String]

    DoublePointValue::new

    source
    fn DoublePointValue::new(state : Int, quality? : StatusQuality) -> Result[DoublePointValue, String]

    DoublePointValue::quality

    source

    DoublePointValue::state

    source
    fn DoublePointValue::state(self : DoublePointValue) -> Int

    DoublePointValue::to_byte

    source
    fn DoublePointValue::to_byte(self : DoublePointValue) -> Int

    EventLog

    source
    pub struct EventLog {
      events : Array[ProtocolEvent]
    }

    In-memory event log for examples, tests and host applications.

    EventLog::all

    source
    fn EventLog::all(self : EventLog) -> Array[ProtocolEvent]

    EventLog::len

    source
    fn EventLog::len(self : EventLog) -> Int

    EventLog::new

    source
    fn EventLog::new() -> EventLog

    EventLog::push

    source
    fn EventLog::push(self : EventLog, event : ProtocolEvent) -> Unit

    FailoverEvent

    source
    pub struct FailoverEvent {
      station : CommonAddress
      from_peer : Int?
      to_peer : Int?
      reason : FailoverReason
      timestamp : Int
      fencing_token : Int
      message : String
    } derive(Eq, 
    Debug    )

    Ownership transition emitted by the redundancy manager.

    FailoverEvent::fencing_token

    source
    fn FailoverEvent::fencing_token(self : FailoverEvent) -> Int

    FailoverEvent::from_peer

    source
    fn FailoverEvent::from_peer(self : FailoverEvent) -> Int?

    FailoverEvent::message

    source
    fn FailoverEvent::message(self : FailoverEvent) -> String

    FailoverEvent::reason

    source

    FailoverEvent::station

    source

    FailoverEvent::timestamp

    source
    fn FailoverEvent::timestamp(self : FailoverEvent) -> Int

    FailoverEvent::to_peer

    source
    fn FailoverEvent::to_peer(self : FailoverEvent) -> Int?

    FailoverReason

    source
    pub enum FailoverReason {
      StartupElection
      HeartbeatTimeout
      ProtocolFault
      ManualTakeover
      PeerRecovered
      FencingRequired
    } derive(Eq, 
    Debug    )

    Why ownership of a redundant station changed.

    FileIdentity

    source
    pub struct FileIdentity {
      station : CommonAddress
      name : String
      file_id : Int
    } derive(Eq, 
    Debug    )

    A file identity used by the file service layer.

    FileIdentity::file_id

    source
    fn FileIdentity::file_id(self : FileIdentity) -> Int

    FileIdentity::name

    source
    fn FileIdentity::name(self : FileIdentity) -> String

    FileIdentity::new

    source
    fn FileIdentity::new(station : CommonAddress, name : String, file_id : Int) -> Result[FileIdentity, String]

    FileIdentity::station

    source
    fn FileIdentity::station(self : FileIdentity) -> CommonAddress

    FileInventoryEntry

    source
    pub struct FileInventoryEntry {
      identity : FileIdentity
      size : Int
      revision : Int
      checksum : UInt
      updated_at : Int
    } derive(Eq, 
    Debug    )

    A file inventory entry returned to operational clients.

    FileInventoryEntry::checksum

    source
    fn FileInventoryEntry::checksum(self : FileInventoryEntry) -> UInt

    FileInventoryEntry::identity

    source

    FileInventoryEntry::revision

    source
    fn FileInventoryEntry::revision(self : FileInventoryEntry) -> Int

    FileInventoryEntry::size

    source
    fn FileInventoryEntry::size(self : FileInventoryEntry) -> Int

    FileInventoryEntry::updated_at

    source
    fn FileInventoryEntry::updated_at(self : FileInventoryEntry) -> Int

    FileSegment

    source
    pub struct FileSegment {
      file_id : Int
      section : Int
      offset : Int
      data : Bytes
      last : Bool
      checksum : UInt
    } derive(Eq, 
    Debug    )

    Segment of a file containing an offset and an end marker.

    FileSegment::checksum

    source
    fn FileSegment::checksum(self : FileSegment) -> UInt

    FileSegment::data

    source
    fn FileSegment::data(self : FileSegment) -> Bytes

    FileSegment::file_id

    source
    fn FileSegment::file_id(self : FileSegment) -> Int

    FileSegment::last

    source
    fn FileSegment::last(self : FileSegment) -> Bool

    FileSegment::new

    source
    fn FileSegment::new(file_id : Int, section : Int, offset : Int, data : Bytes, last : Bool) -> Result[FileSegment, String]

    FileSegment::offset

    source
    fn FileSegment::offset(self : FileSegment) -> Int

    FileSegment::section

    source
    fn FileSegment::section(self : FileSegment) -> Int

    FileSegment::valid_checksum

    source
    fn FileSegment::valid_checksum(self : FileSegment) -> Bool

    FileStore

    source
    pub struct FileStore {
      files : Map[String, StoredFile]
      capacity : Int
      maximum_size : Int
    } derive(
    Debug    )

    A bounded in-memory store used by outstations and gateway adapters.

    FileStore::capacity

    source
    fn FileStore::capacity(self : FileStore) -> Int

    FileStore::get

    source
    fn FileStore::get(self : FileStore, name : String) -> StoredFile?

    FileStore::inventory

    source
    fn FileStore::inventory(self : FileStore) -> Array[FileInventoryEntry]

    FileStore::len

    source
    fn FileStore::len(self : FileStore) -> Int

    FileStore::maximum_size

    source
    fn FileStore::maximum_size(self : FileStore) -> Int

    FileStore::new

    source
    fn FileStore::new(capacity? : Int, maximum_size? : Int) -> Result[FileStore, String]

    FileStore::put

    source
    fn FileStore::put(self : FileStore, identity : FileIdentity, data : Bytes, timestamp : Int) -> Result[StoredFile, String]

    FileStore::remove

    source
    fn FileStore::remove(self : FileStore, name : String) -> Result[StoredFile, String]

    FileTransferDirection

    source
    pub enum FileTransferDirection {
      UploadFile
      DownloadFile
    } derive(Eq, 
    Debug    )

    Direction of a file service request.

    FileTransferManager

    source
    pub struct FileTransferManager {
      store : FileStore
      sessions : Map[Int, FileTransferSession]
      history : Array[FileTransferSession]
      history_limit : Int
      next_ticket : Int
      metrics : FileTransferMetrics
    } derive(
    Debug    )

    File service coordinator for stores and station sessions.

    FileTransferManager::ack

    source
    fn FileTransferManager::ack(self : FileTransferManager, ticket : Int, timestamp : Int) -> Result[Unit, String]

    FileTransferManager::activate

    source
    fn FileTransferManager::activate(self : FileTransferManager, ticket : Int, timestamp : Int) -> Result[Unit, String]

    FileTransferManager::append

    source
    fn FileTransferManager::append(self : FileTransferManager, ticket : Int, segment : FileSegment, timestamp : Int) -> Result[FileTransferState, String]

    FileTransferManager::begin_download

    source
    fn FileTransferManager::begin_download(self : FileTransferManager, identity : FileIdentity, segment_size? : Int, timestamp? : Int) -> Result[Array[FileSegment], String]

    FileTransferManager::begin_upload

    source
    fn FileTransferManager::begin_upload(self : FileTransferManager, identity : FileIdentity, expected_size : Int, expected_checksum? : UInt, segment_size? : Int, timestamp? : Int) -> Result[FileTransferSession, String]

    FileTransferManager::cancel

    source
    fn FileTransferManager::cancel(self : FileTransferManager, ticket : Int, timestamp : Int) -> Result[Unit, String]

    FileTransferManager::finish

    source
    fn FileTransferManager::finish(self : FileTransferManager, ticket : Int, timestamp : Int) -> Result[StoredFile, String]

    FileTransferManager::get

    source

    FileTransferManager::history

    source

    FileTransferManager::metrics

    source

    FileTransferManager::new

    source
    fn FileTransferManager::new(store : FileStore, history_limit? : Int) -> Result[FileTransferManager, String]

    FileTransferManager::session_count

    source
    fn FileTransferManager::session_count(self : FileTransferManager) -> Int

    FileTransferManager::store

    source

    FileTransferMetrics

    source
    pub struct FileTransferMetrics {
      sessions : Int
      completed : Int
      failed : Int
      cancelled : Int
      segments : Int
      bytes : Int
    } derive(Eq, 
    Debug    )

    Counters for file service throughput and failures.

    FileTransferMetrics::bytes

    source
    fn FileTransferMetrics::bytes(self : FileTransferMetrics) -> Int

    FileTransferMetrics::cancelled

    source
    fn FileTransferMetrics::cancelled(self : FileTransferMetrics) -> Int

    FileTransferMetrics::completed

    source
    fn FileTransferMetrics::completed(self : FileTransferMetrics) -> Int

    FileTransferMetrics::failed

    source
    fn FileTransferMetrics::failed(self : FileTransferMetrics) -> Int

    FileTransferMetrics::new

    source

    FileTransferMetrics::segments

    source
    fn FileTransferMetrics::segments(self : FileTransferMetrics) -> Int

    FileTransferMetrics::sessions

    source
    fn FileTransferMetrics::sessions(self : FileTransferMetrics) -> Int

    FileTransferSession

    source
    pub struct FileTransferSession {
      ticket : Int
      identity : FileIdentity
      direction : FileTransferDirection
      expected_size : Int
      segment_size : Int
      expected_checksum : UInt?
      buffer : Array[Byte]
      next_offset : Int
      next_section : Int
      state : FileTransferState
      attempts : Int
      last_activity : Int
      error : String
    } derive(
    Debug    )

    File transfer session with ordered segment assembly.

    FileTransferSession::ack

    source
    fn FileTransferSession::ack(self : FileTransferSession, timestamp : Int) -> Result[Unit, String]

    FileTransferSession::activate

    source
    fn FileTransferSession::activate(self : FileTransferSession, timestamp : Int) -> Result[Unit, String]

    FileTransferSession::append

    source
    fn FileTransferSession::append(self : FileTransferSession, segment : FileSegment, timestamp : Int) -> Result[Unit, String]

    FileTransferSession::attempts

    source
    fn FileTransferSession::attempts(self : FileTransferSession) -> Int

    FileTransferSession::cancel

    source
    fn FileTransferSession::cancel(self : FileTransferSession, timestamp : Int) -> Result[Unit, String]

    FileTransferSession::data

    source
    fn FileTransferSession::data(self : FileTransferSession) -> Bytes

    FileTransferSession::direction

    source

    FileTransferSession::error

    source
    fn FileTransferSession::error(self : FileTransferSession) -> String

    FileTransferSession::expected_checksum

    source
    fn FileTransferSession::expected_checksum(self : FileTransferSession) -> UInt?

    FileTransferSession::expected_size

    source
    fn FileTransferSession::expected_size(self : FileTransferSession) -> Int

    FileTransferSession::fail

    source
    fn FileTransferSession::fail(self : FileTransferSession, timestamp : Int, message : String) -> Unit

    FileTransferSession::identity

    source

    FileTransferSession::last_activity

    source
    fn FileTransferSession::last_activity(self : FileTransferSession) -> Int

    FileTransferSession::new

    source
    fn FileTransferSession::new(ticket : Int, identity : FileIdentity, direction : FileTransferDirection, expected_size : Int, segment_size : Int, expected_checksum : UInt?, timestamp : Int) -> Result[FileTransferSession, String]

    FileTransferSession::next_offset

    source
    fn FileTransferSession::next_offset(self : FileTransferSession) -> Int

    FileTransferSession::next_section

    source
    fn FileTransferSession::next_section(self : FileTransferSession) -> Int

    FileTransferSession::received_size

    source
    fn FileTransferSession::received_size(self : FileTransferSession) -> Int

    FileTransferSession::segment_size

    source
    fn FileTransferSession::segment_size(self : FileTransferSession) -> Int

    FileTransferSession::state

    source

    FileTransferSession::ticket

    source
    fn FileTransferSession::ticket(self : FileTransferSession) -> Int

    FileTransferState

    source
    pub enum FileTransferState {
      FileIdle
      FileSelecting
      FileTransferring
      FileWaitingForAck
      FileCompleted
      FileFailed
      FileCancelled
    } derive(Eq, 
    Debug    )

    State of a bounded IEC 104 file transfer session.

    Frame

    source
    pub struct Frame {
      kind : FrameKind
      send_sequence : Int
      receive_sequence : Int
      control : UInt16
      payload : Bytes
    } derive(Eq, 
    Debug    )

    A decoded APCI frame. payload contains the ASDU for I frames.

    Frame::control

    source
    fn Frame::control(self : Frame) -> UInt16

    Frame::is_information

    source
    fn Frame::is_information(self : Frame) -> Bool

    Frame::is_supervisory

    source
    fn Frame::is_supervisory(self : Frame) -> Bool

    Frame::is_unnumbered

    source
    fn Frame::is_unnumbered(self : Frame) -> Bool

    Frame::kind

    source
    fn Frame::kind(self : Frame) -> FrameKind

    Stable accessors for frame values used by host integrations.

    Frame::payload

    source
    fn Frame::payload(self : Frame) -> Bytes

    Frame::receive_sequence

    source
    fn Frame::receive_sequence(self : Frame) -> Int

    Frame::send_sequence

    source
    fn Frame::send_sequence(self : Frame) -> Int

    FrameKind

    source
    pub enum FrameKind {
      Information
      Supervisory
      Unnumbered
    } derive(Eq, 
    Debug    )

    IEC 60870-5-104 frame kinds.

    FrameMetrics

    source
    pub struct FrameMetrics {
      frames_encoded : Int
      frames_decoded : Int
      information_frames : Int
      supervisory_frames : Int
      unnumbered_frames : Int
      bytes_encoded : Int
      bytes_decoded : Int
      malformed_frames : Int
      sequence_errors : Int
      service_failures : Int
    } derive(Eq, 
    Debug    )

    Counters for protocol throughput and error monitoring.

    FrameMetrics::error_count

    source
    fn FrameMetrics::error_count(self : FrameMetrics) -> Int

    FrameMetrics::new

    source

    FrameMetrics::record_decoded

    source
    fn FrameMetrics::record_decoded(self : FrameMetrics, frame : Frame) -> Unit

    FrameMetrics::record_encoded

    source
    fn FrameMetrics::record_encoded(self : FrameMetrics, frame : Frame) -> Unit

    FrameMetrics::record_malformed

    source
    fn FrameMetrics::record_malformed(self : FrameMetrics) -> Unit

    FrameMetrics::record_sequence_error

    source
    fn FrameMetrics::record_sequence_error(self : FrameMetrics) -> Unit

    FrameMetrics::record_service_failure

    source
    fn FrameMetrics::record_service_failure(self : FrameMetrics) -> Unit

    FrameMetrics::snapshot

    source
    fn FrameMetrics::snapshot(self : FrameMetrics) -> MetricsSnapshot

    FrameMetrics::success_rate

    source
    fn FrameMetrics::success_rate(self : FrameMetrics) -> Float

    FrameMetrics::total_bytes

    source
    fn FrameMetrics::total_bytes(self : FrameMetrics) -> Int

    FrameMetrics::total_frames

    source
    fn FrameMetrics::total_frames(self : FrameMetrics) -> Int

    GatewayAdmissionPolicy

    source
    pub struct GatewayAdmissionPolicy {
      max_objects : Int
      allow_monitoring : Bool
      allow_control : Bool
      allowed_types : Array[ApplicationType]
      denied_types : Array[ApplicationType]
    } derive(Eq, 
    Debug    )

    Admission policy applied before a gateway accepts an ASDU.

    GatewayAdmissionPolicy::allow_type

    source
    fn GatewayAdmissionPolicy::allow_type(self : GatewayAdmissionPolicy, type_id : ApplicationType) -> Unit

    GatewayAdmissionPolicy::default

    source

    GatewayAdmissionPolicy::deny_type

    source
    fn GatewayAdmissionPolicy::deny_type(self : GatewayAdmissionPolicy, type_id : ApplicationType) -> Unit

    GatewayAdmissionPolicy::evaluate

    source
    fn GatewayAdmissionPolicy::evaluate(self : GatewayAdmissionPolicy, envelope : AsduEnvelope) -> Result[Unit, String]

    GatewayAdmissionPolicy::max_objects

    source
    fn GatewayAdmissionPolicy::max_objects(self : GatewayAdmissionPolicy) -> Int

    GatewayAdmissionPolicy::new

    source
    fn GatewayAdmissionPolicy::new(max_objects : Int, allow_monitoring? : Bool, allow_control? : Bool) -> Result[GatewayAdmissionPolicy, String]

    GatewayCounters

    source
    pub struct GatewayCounters {
      accepted : Int
      forwarded : Int
      dropped : Int
      rejected : Int
      stored : Int
    } derive(Eq, 
    Debug    )

    Counters exposed by the gateway for operational dashboards.

    GatewayCounters::accepted

    source
    fn GatewayCounters::accepted(self : GatewayCounters) -> Int

    GatewayCounters::dropped

    source
    fn GatewayCounters::dropped(self : GatewayCounters) -> Int

    GatewayCounters::empty

    source

    GatewayCounters::forwarded

    source
    fn GatewayCounters::forwarded(self : GatewayCounters) -> Int

    GatewayCounters::rejected

    source
    fn GatewayCounters::rejected(self : GatewayCounters) -> Int

    GatewayCounters::stored

    source
    fn GatewayCounters::stored(self : GatewayCounters) -> Int

    GatewayCounters::total

    source
    fn GatewayCounters::total(self : GatewayCounters) -> Int

    GatewayDispatch

    source
    pub enum GatewayDispatch {
      Forwarded(GatewayEnvelope, GatewayRoute)
      Dropped(GatewayEnvelope, String)
    } derive(
    Debug    )

    GatewayDispatch::envelope

    source

    GatewayDispatch::is_forwarded

    source
    fn GatewayDispatch::is_forwarded(self : GatewayDispatch) -> Bool

    GatewayDispatch::message

    source
    fn GatewayDispatch::message(self : GatewayDispatch) -> String

    GatewayEnvelope

    source
    pub struct GatewayEnvelope {
      ingress : Int
      egress : Int
      common_address : CommonAddress
      asdu : AsduEnvelope
      received_at : Int
      trace_id : String
    } derive(
    Debug    )

    An ASDU together with gateway ingress metadata.

    GatewayEnvelope::asdu

    source

    GatewayEnvelope::common_address

    source
    fn GatewayEnvelope::common_address(self : GatewayEnvelope) -> CommonAddress

    GatewayEnvelope::egress

    source
    fn GatewayEnvelope::egress(self : GatewayEnvelope) -> Int

    GatewayEnvelope::ingress

    source
    fn GatewayEnvelope::ingress(self : GatewayEnvelope) -> Int

    GatewayEnvelope::new

    source
    fn GatewayEnvelope::new(ingress : Int, egress : Int, asdu : AsduEnvelope, received_at : Int, trace_id? : String) -> Result[GatewayEnvelope, String]

    GatewayEnvelope::object_count

    source
    fn GatewayEnvelope::object_count(self : GatewayEnvelope) -> Int

    GatewayEnvelope::received_at

    source
    fn GatewayEnvelope::received_at(self : GatewayEnvelope) -> Int

    GatewayEnvelope::trace_id

    source
    fn GatewayEnvelope::trace_id(self : GatewayEnvelope) -> String

    GatewayMode

    source
    pub enum GatewayMode {
      Stopped
      Starting
      Running
      Draining
      Faulted(String)
    } derive(Eq, 
    Debug    )

    Lifecycle of an in-memory IEC 104 gateway runtime.

    GatewayMode::is_accepting

    source
    fn GatewayMode::is_accepting(self : GatewayMode) -> Bool

    GatewayMode::is_quiescent

    source
    fn GatewayMode::is_quiescent(self : GatewayMode) -> Bool

    GatewayMode::name

    source
    fn GatewayMode::name(self : GatewayMode) -> String

    GatewayRoute

    source
    pub struct GatewayRoute {
      id : Int
      source : Int
      destination : Int
      common_address : CommonAddress?
      type_ids : Array[ApplicationType]
      enabled : Bool
      priority : Int
    } derive(Eq, 
    Debug    )

    A route between two logical gateway endpoints.

    GatewayRoute::common_address

    source
    fn GatewayRoute::common_address(self : GatewayRoute) -> CommonAddress?

    GatewayRoute::describe

    source
    fn GatewayRoute::describe(self : GatewayRoute) -> String

    GatewayRoute::destination

    source
    fn GatewayRoute::destination(self : GatewayRoute) -> Int

    GatewayRoute::enabled

    source
    fn GatewayRoute::enabled(self : GatewayRoute) -> Bool

    GatewayRoute::id

    source
    fn GatewayRoute::id(self : GatewayRoute) -> Int

    GatewayRoute::new

    source
    fn GatewayRoute::new(id : Int, source : Int, destination : Int, common_address? : CommonAddress, type_ids? : Array[ApplicationType], priority? : Int) -> Result[GatewayRoute, String]

    GatewayRoute::priority

    source
    fn GatewayRoute::priority(self : GatewayRoute) -> Int

    GatewayRoute::set_enabled

    source
    fn GatewayRoute::set_enabled(self : GatewayRoute, enabled : Bool) -> Unit

    GatewayRoute::source

    source
    fn GatewayRoute::source(self : GatewayRoute) -> Int

    GatewayRoute::type_ids

    source

    GatewayRouteTable

    source
    pub struct GatewayRouteTable {
      routes : Array[GatewayRoute]
      capacity : Int
    } derive(
    Debug    )

    Deterministic route table. Higher priority wins; ties use the lower route id.

    GatewayRouteTable::add

    source
    fn GatewayRouteTable::add(self : GatewayRouteTable, route : GatewayRoute) -> Result[Unit, String]

    GatewayRouteTable::capacity

    source
    fn GatewayRouteTable::capacity(self : GatewayRouteTable) -> Int

    GatewayRouteTable::len

    source
    fn GatewayRouteTable::len(self : GatewayRouteTable) -> Int

    GatewayRouteTable::new

    source
    fn GatewayRouteTable::new(capacity? : Int) -> Result[GatewayRouteTable, String]

    GatewayRouteTable::remove

    source
    fn GatewayRouteTable::remove(self : GatewayRouteTable, route_id : Int) -> Bool

    GatewayRouteTable::routes

    source

    GatewayRouteTable::select

    source
    fn GatewayRouteTable::select(self : GatewayRouteTable, source : Int, common_address : CommonAddress, type_id : ApplicationType) -> GatewayRoute?

    GatewayRouteTable::set_enabled

    source
    fn GatewayRouteTable::set_enabled(self : GatewayRouteTable, route_id : Int, enabled : Bool) -> Bool

    GatewayRuntime

    source
    pub struct GatewayRuntime {
      mode : GatewayMode
      routes : GatewayRouteTable
      policy : GatewayAdmissionPolicy
      inbound : Array[GatewayEnvelope]
      outbound : Array[GatewayEnvelope]
      dead_letters : Array[GatewayEnvelope]
      stores : Array[GatewayStoreBinding]
      counters : GatewayCounters
      max_queue : Int
      last_error : String?
    } derive(
    Debug    )

    Deterministic in-memory routing runtime. Network adapters can feed its queue and poll the outbound queue without coupling protocol logic to a socket API.

    GatewayRuntime::add_route

    source
    fn GatewayRuntime::add_route(self : GatewayRuntime, route : GatewayRoute) -> Result[Unit, String]

    GatewayRuntime::attach_store

    source
    fn GatewayRuntime::attach_store(self : GatewayRuntime, binding : GatewayStoreBinding) -> Result[Unit, String]

    GatewayRuntime::begin_drain

    source
    fn GatewayRuntime::begin_drain(self : GatewayRuntime) -> Result[Unit, String]

    GatewayRuntime::counters

    source

    GatewayRuntime::dead_letter_len

    source
    fn GatewayRuntime::dead_letter_len(self : GatewayRuntime) -> Int

    GatewayRuntime::diagnostics

    source
    fn GatewayRuntime::diagnostics(self : GatewayRuntime) -> String

    Return a stable, line-oriented diagnostics report for logs and health probes.

    GatewayRuntime::drain

    source
    fn GatewayRuntime::drain(self : GatewayRuntime, max_dispatches? : Int) -> Array[GatewayDispatch]

    GatewayRuntime::enqueue

    source
    fn GatewayRuntime::enqueue(self : GatewayRuntime, envelope : GatewayEnvelope) -> Result[Unit, String]

    GatewayRuntime::fail

    source
    fn GatewayRuntime::fail(self : GatewayRuntime, message : String) -> Unit

    GatewayRuntime::ingest_to_store

    source
    fn GatewayRuntime::ingest_to_store(self : GatewayRuntime, envelope : GatewayEnvelope) -> Result[Int, String]

    GatewayRuntime::last_error

    source
    fn GatewayRuntime::last_error(self : GatewayRuntime) -> String?

    GatewayRuntime::mode

    source

    GatewayRuntime::new

    source
    fn GatewayRuntime::new(max_queue : Int, route_capacity? : Int, policy? : GatewayAdmissionPolicy) -> Result[GatewayRuntime, String]

    GatewayRuntime::outbound_len

    source
    fn GatewayRuntime::outbound_len(self : GatewayRuntime) -> Int

    GatewayRuntime::poll_outbound

    source
    fn GatewayRuntime::poll_outbound(self : GatewayRuntime) -> GatewayEnvelope?

    GatewayRuntime::queue_len

    source
    fn GatewayRuntime::queue_len(self : GatewayRuntime) -> Int

    GatewayRuntime::remove_route

    source
    fn GatewayRuntime::remove_route(self : GatewayRuntime, route_id : Int) -> Bool

    GatewayRuntime::routes

    source

    GatewayRuntime::set_policy

    source
    fn GatewayRuntime::set_policy(self : GatewayRuntime, policy : GatewayAdmissionPolicy) -> Unit

    GatewayRuntime::snapshot

    source

    GatewayRuntime::start

    source
    fn GatewayRuntime::start(self : GatewayRuntime) -> Result[Unit, String]

    GatewayRuntime::stop

    source
    fn GatewayRuntime::stop(self : GatewayRuntime) -> Result[Unit, String]

    GatewayRuntime::store_count

    source
    fn GatewayRuntime::store_count(self : GatewayRuntime) -> Int

    GatewayRuntime::take_dead_letter

    source
    fn GatewayRuntime::take_dead_letter(self : GatewayRuntime) -> GatewayEnvelope?

    GatewaySnapshot

    source
    pub struct GatewaySnapshot {
      mode : GatewayMode
      routes : Int
      queue : Int
      outbound : Int
      dead_letters : Int
      counters : GatewayCounters
      last_error : String?
    } derive(Eq, 
    Debug    )

    Snapshot suitable for a health endpoint or a periodic metrics export.

    GatewaySnapshot::counters

    source

    GatewaySnapshot::dead_letters

    source
    fn GatewaySnapshot::dead_letters(self : GatewaySnapshot) -> Int

    GatewaySnapshot::last_error

    source
    fn GatewaySnapshot::last_error(self : GatewaySnapshot) -> String?

    GatewaySnapshot::mode

    source

    GatewaySnapshot::outbound

    source
    fn GatewaySnapshot::outbound(self : GatewaySnapshot) -> Int

    GatewaySnapshot::queue

    source
    fn GatewaySnapshot::queue(self : GatewaySnapshot) -> Int

    GatewaySnapshot::routes

    source
    fn GatewaySnapshot::routes(self : GatewaySnapshot) -> Int

    GatewayStoreBinding

    source
    pub struct GatewayStoreBinding {
      common_address : CommonAddress
      store : PointStore
      accepted : Int
      rejected : Int
    } derive(
    Debug    )

    A point store attached to one common address in the gateway.

    GatewayStoreBinding::accepted

    source
    fn GatewayStoreBinding::accepted(self : GatewayStoreBinding) -> Int

    GatewayStoreBinding::common_address

    source

    GatewayStoreBinding::ingest

    source
    fn GatewayStoreBinding::ingest(self : GatewayStoreBinding, envelope : GatewayEnvelope) -> Result[Int, String]

    GatewayStoreBinding::new

    source
    fn GatewayStoreBinding::new(common_address : CommonAddress, history_limit? : Int) -> Result[GatewayStoreBinding, String]

    GatewayStoreBinding::rejected

    source
    fn GatewayStoreBinding::rejected(self : GatewayStoreBinding) -> Int

    GatewayStoreBinding::store

    source

    HealthReport

    source
    pub struct HealthReport {
      state : HealthState
      score : Int
      checks : Array[String]
      warnings : Array[String]
    } derive(Eq, 
    Debug    )

    HealthReport::checks

    source
    fn HealthReport::checks(self : HealthReport) -> Array[String]

    HealthReport::new

    source
    fn HealthReport::new(state : HealthState, score : Int, checks : Array[String], warnings : Array[String]) -> HealthReport

    HealthReport::score

    source
    fn HealthReport::score(self : HealthReport) -> Int

    HealthReport::state

    source

    HealthReport::warnings

    source
    fn HealthReport::warnings(self : HealthReport) -> Array[String]

    HealthState

    source
    pub enum HealthState {
      Healthy
      Degraded
      Unready
    } derive(Eq, 
    Debug    )

    Health state suitable for gateway readiness endpoints.

    Iec104Runtime

    source
    pub struct Iec104Runtime {
      database : StationDatabase
      telemetry : TelemetryPipeline
      schedulers : Map[Int, CommandScheduler]
      redundancy : Map[Int, RedundancyManager]
      policy : OperationalPolicy
      redundancy_policy : RedundancyPolicy
      files : FileTransferManager
      clock : VirtualClock
      events : Array[RuntimeEvent]
      event_limit : Int
      next_event : Int
      metrics : RuntimeMetrics
    } derive(
    Debug    )

    Integration facade connecting data, control, policy and redundancy layers.

    Iec104Runtime::add_peer

    source
    fn Iec104Runtime::add_peer(self : Iec104Runtime, peer : RedundantPeer) -> Result[Unit, String]

    Iec104Runtime::confirm_command

    source
    fn Iec104Runtime::confirm_command(self : Iec104Runtime, station : CommonAddress, ticket : Int, accepted : Bool, message? : String) -> Result[CommandRequest, Diagnostic]

    Iec104Runtime::database

    source

    Iec104Runtime::dispatch_command

    source
    fn Iec104Runtime::dispatch_command(self : Iec104Runtime, station : CommonAddress, policy : CommandPolicy) -> Result[CommandDispatch?, Diagnostic]

    Iec104Runtime::events

    source

    Iec104Runtime::files

    source

    Iec104Runtime::health

    source

    Iec104Runtime::heartbeat

    source
    fn Iec104Runtime::heartbeat(self : Iec104Runtime, station : CommonAddress, peer_id : Int) -> Result[Unit, String]

    Iec104Runtime::ingest

    source
    fn Iec104Runtime::ingest(self : Iec104Runtime, station : CommonAddress, object : ApplicationObject, source? : String) -> Result[PipelineResult, Diagnostic]

    Iec104Runtime::metrics

    source

    Iec104Runtime::new

    source
    fn Iec104Runtime::new(config? : RuntimeConfig) -> Result[Iec104Runtime, String]

    Iec104Runtime::now

    source
    fn Iec104Runtime::now(self : Iec104Runtime) -> Int

    Iec104Runtime::policy

    source

    Iec104Runtime::register_station

    source
    fn Iec104Runtime::register_station(self : Iec104Runtime, config : StationConfig) -> Result[StationSummary, String]

    Iec104Runtime::submit_command

    source
    fn Iec104Runtime::submit_command(self : Iec104Runtime, operator_id : String, station : CommonAddress, object : ApplicationObject, priority : CommandPriority, deadline : Int, idempotency_key : String) -> Result[CommandRequest, Diagnostic]

    Iec104Runtime::telemetry

    source

    Iec104Runtime::tick

    source
    fn Iec104Runtime::tick(self : Iec104Runtime, seconds : Int) -> Result[Unit, String]

    InformationAddress

    source
    pub struct InformationAddress {
      value : Int
    } derive(Eq, 
    Debug    )

    The three-byte information object address used by IEC 104.

    InformationAddress::from_octets

    source
    fn InformationAddress::from_octets(low : Int, middle : Int, high : Int) -> Result[InformationAddress, String]

    Construct an information object address from its three octets.

    InformationAddress::high

    source
    fn InformationAddress::high(self : InformationAddress) -> Int

    Return the most significant address octet.

    InformationAddress::is_broadcast

    source
    fn InformationAddress::is_broadcast(self : InformationAddress) -> Bool

    Return whether the address is the protocol's broadcast address.

    InformationAddress::low

    source
    fn InformationAddress::low(self : InformationAddress) -> Int

    Return the least significant address octet.

    InformationAddress::middle

    source
    fn InformationAddress::middle(self : InformationAddress) -> Int

    Return the middle address octet.

    InformationAddress::new

    source
    fn InformationAddress::new(value : Int) -> Result[InformationAddress, String]

    Create an information object address in the inclusive 0..0xffffff range.

    InformationAddress::number

    source
    fn InformationAddress::number(self : InformationAddress) -> Int

    Return the numeric address.

    InformationObject

    source
    pub enum InformationObject {
      Single(Bool, Int)
      Double(Int, Int)
      Normalized(Int, Int)
      ShortFloat(Float, Int)
      BitString(UInt, Int)
    } derive(Eq, 
    Debug    )

    IEC information object values supported by the first stable API.

    Interrogation

    source
    pub struct Interrogation {
      request : InterrogationRequest
      phase : InterrogationPhase
      objects_sent : Int
    }

    Small deterministic transaction tracker; data transport remains caller-owned.

    Interrogation::activate

    source
    fn Interrogation::activate(self : Interrogation) -> Int

    Interrogation::finish

    source
    fn Interrogation::finish(self : Interrogation) -> Int

    Interrogation::new

    source

    Interrogation::record

    source
    fn Interrogation::record(self : Interrogation, count : Int) -> Result[Unit, String]

    InterrogationPhase

    source
    pub enum InterrogationPhase {
      Idle
      Activated
      Sending
      Terminated
    } derive(Eq, 
    Debug    )

    Phases emitted by an interrogation transaction.

    InterrogationPlan

    source
    pub struct InterrogationPlan {
      request : InterrogationRequest
      objects : Array[ApplicationObject]
      batch_size : Int
      cursor : Int
      status : ServiceStatus
    } derive(
    Debug    )

    A total interrogation plan which can be emitted in deterministic batches.

    InterrogationPlan::activate

    source
    fn InterrogationPlan::activate(self : InterrogationPlan) -> Result[Int, String]

    InterrogationPlan::new

    source
    fn InterrogationPlan::new(request : InterrogationRequest, objects : Array[ApplicationObject], batch_size? : Int) -> Result[InterrogationPlan, String]

    InterrogationPlan::next_batch

    source
    fn InterrogationPlan::next_batch(self : InterrogationPlan) -> Result[Array[ApplicationObject], String]

    InterrogationPlan::remaining

    source
    fn InterrogationPlan::remaining(self : InterrogationPlan) -> Int

    InterrogationPlan::request

    source

    InterrogationPlan::status

    source

    InterrogationPlan::terminate

    source
    fn InterrogationPlan::terminate(self : InterrogationPlan) -> Result[Int, String]

    InterrogationRequest

    source
    pub struct InterrogationRequest {
      common_address : Int
      qualifier : Int
    } derive(Eq, 
    Debug    )

    A total interrogation request, suitable for a master command queue.

    InterrogationRequest::new

    source
    fn InterrogationRequest::new(common_address : Int, qualifier? : Int) -> InterrogationRequest

    LengthHistogram

    source
    pub struct LengthHistogram {
      buckets : Map[Int, Int]
      samples : Int
    } derive(
    Debug    )

    A compact histogram for APDU length distribution.

    LengthHistogram::all

    source
    fn LengthHistogram::all(self : LengthHistogram) -> Array[(Int, Int)]

    LengthHistogram::bucket

    source
    fn LengthHistogram::bucket(self : LengthHistogram, maximum : Int) -> Int

    LengthHistogram::new

    source

    LengthHistogram::observe

    source
    fn LengthHistogram::observe(self : LengthHistogram, length : Int) -> Unit

    LengthHistogram::samples

    source
    fn LengthHistogram::samples(self : LengthHistogram) -> Int

    LinkHealth

    source
    pub enum LinkHealth {
      HealthyLink
      SuspectLink
      FailedLink
      RecoveringLink
    } derive(Eq, 
    Debug    )

    Health state used by the failover election.

    LinkHealth::examples

    source
    fn LinkHealth::examples() -> Array[LinkHealth]

    LinkState

    source
    pub enum LinkState {
      Disconnected
      Connecting
      Started
      Stopped
      TestPending
    } derive(Eq, 
    Debug    )

    Link-layer state used by a master or outstation session.

    LinkState::is_connected

    source
    fn LinkState::is_connected(self : LinkState) -> Bool

    LinkState::is_terminal

    source
    fn LinkState::is_terminal(self : LinkState) -> Bool

    MaintenanceWindow

    source
    pub struct MaintenanceWindow {
      id : Int
      station : CommonAddress?
      start : Int
      end : Int
      reason : String
      blocks_commands : Bool
      blocks_file_writes : Bool
      enabled : Bool
    } derive(Eq, 
    Debug    )

    A bounded maintenance interval during which risky actions are blocked.

    MaintenanceWindow::blocks_commands

    source
    fn MaintenanceWindow::blocks_commands(self : MaintenanceWindow) -> Bool

    MaintenanceWindow::blocks_file_writes

    source
    fn MaintenanceWindow::blocks_file_writes(self : MaintenanceWindow) -> Bool

    MaintenanceWindow::contains

    source
    fn MaintenanceWindow::contains(self : MaintenanceWindow, station : CommonAddress, timestamp : Int) -> Bool

    MaintenanceWindow::disable

    source
    fn MaintenanceWindow::disable(self : MaintenanceWindow) -> Unit

    MaintenanceWindow::enabled

    source
    fn MaintenanceWindow::enabled(self : MaintenanceWindow) -> Bool

    MaintenanceWindow::end

    source
    fn MaintenanceWindow::end(self : MaintenanceWindow) -> Int

    MaintenanceWindow::id

    source
    fn MaintenanceWindow::id(self : MaintenanceWindow) -> Int

    MaintenanceWindow::new

    source
    fn MaintenanceWindow::new(id : Int, start : Int, end : Int, reason : String, station? : CommonAddress, blocks_commands? : Bool, blocks_file_writes? : Bool) -> Result[MaintenanceWindow, String]

    MaintenanceWindow::reason

    source
    fn MaintenanceWindow::reason(self : MaintenanceWindow) -> String

    MaintenanceWindow::start

    source
    fn MaintenanceWindow::start(self : MaintenanceWindow) -> Int

    MaintenanceWindow::station

    source

    ManagedTransportState

    source
    pub enum ManagedTransportState {
      TransportCreated
      TransportConnecting
      TransportStarted
      TransportStopping
      TransportStopped
      TransportFailed
      TransportClosed
    } derive(Eq, 
    Debug    )

    State of a managed transport endpoint.

    MeasurementState

    source
    pub enum MeasurementState {
      Good
      Blocked
      Substituted
      NotTopical
      Invalid
    } derive(Eq, 
    Debug    )

    Quality-preserving measurement classification used by point stores.

    MetricsSnapshot

    source
    pub struct MetricsSnapshot {
      frames : Int
      bytes : Int
      errors : Int
      success_rate : Float
    } derive(Eq, 
    Debug    )

    Snapshot an evolving metrics object for export or health endpoints.

    MetricsSnapshot::bytes

    source
    fn MetricsSnapshot::bytes(self : MetricsSnapshot) -> Int

    MetricsSnapshot::errors

    source
    fn MetricsSnapshot::errors(self : MetricsSnapshot) -> Int

    MetricsSnapshot::frames

    source
    fn MetricsSnapshot::frames(self : MetricsSnapshot) -> Int

    MetricsSnapshot::success_rate

    source
    fn MetricsSnapshot::success_rate(self : MetricsSnapshot) -> Float

    NegotiationDecision

    source
    pub enum NegotiationDecision {
      CompatibleProfile
      IncompatibleProfile(Array[String])
    } derive(
    Debug    )

    NormalizedValue

    source
    pub struct NormalizedValue {
      value : Int
      quality : QualityDescriptor
    } derive(Eq, 
    Debug    )

    Normalized signed 16-bit measurement.

    NormalizedValue::new

    source
    fn NormalizedValue::new(value : Int, quality? : QualityDescriptor) -> Result[NormalizedValue, String]

    NormalizedValue::quality

    source

    NormalizedValue::raw_unsigned

    source
    fn NormalizedValue::raw_unsigned(self : NormalizedValue) -> Int

    NormalizedValue::to_array

    source
    fn NormalizedValue::to_array(self : NormalizedValue) -> Array[Byte]

    NormalizedValue::value

    source
    fn NormalizedValue::value(self : NormalizedValue) -> Int

    OperationalPermission

    source
    pub enum OperationalPermission {
      ViewTelemetry
      ViewDiagnostics
      ReadFiles
      WriteFiles
      SubmitCommands
      ConfirmCommands
      ManageStations
      ManageRoutes
      ManagePolicies
      PerformFailover
    } derive(Eq, 
    Debug    )

    Fine-grained operations that can be authorized.

    OperationalPolicy

    source
    pub struct OperationalPolicy {
      rules : Array[PolicyRule]
      windows : Array[MaintenanceWindow]
      identities : Map[String, OperatorIdentity]
      journal : PolicyAuditJournal
      revision : Int
    } derive(
    Debug    )

    Central policy evaluator for operator-facing services.

    OperationalPolicy::add_identity

    source
    fn OperationalPolicy::add_identity(self : OperationalPolicy, identity : OperatorIdentity) -> Result[Unit, String]

    OperationalPolicy::add_rule

    source
    fn OperationalPolicy::add_rule(self : OperationalPolicy, rule : PolicyRule) -> Result[Unit, String]

    OperationalPolicy::add_window

    source
    fn OperationalPolicy::add_window(self : OperationalPolicy, window : MaintenanceWindow) -> Result[Unit, String]

    OperationalPolicy::authorize

    source
    fn OperationalPolicy::authorize(self : OperationalPolicy, operator_id : String, permission : OperationalPermission, station : CommonAddress, type_id : ApplicationType?, timestamp : Int) -> PolicyDecision

    OperationalPolicy::identity

    source
    fn OperationalPolicy::identity(self : OperationalPolicy, id : String) -> OperatorIdentity?

    OperationalPolicy::journal

    source

    OperationalPolicy::new

    source
    fn OperationalPolicy::new(audit_limit? : Int) -> Result[OperationalPolicy, String]

    OperationalPolicy::remove_identity

    source
    fn OperationalPolicy::remove_identity(self : OperationalPolicy, id : String) -> Result[Unit, String]

    OperationalPolicy::revision

    source
    fn OperationalPolicy::revision(self : OperationalPolicy) -> Int

    OperationalPolicy::windows

    source

    OperatorIdentity

    source
    pub struct OperatorIdentity {
      id : String
      display_name : String
      role : OperatorRole
      stations : Array[CommonAddress]
      active : Bool
    } derive(Eq, 
    Debug    )

    OperatorIdentity::active

    source
    fn OperatorIdentity::active(self : OperatorIdentity) -> Bool

    OperatorIdentity::covers

    source
    fn OperatorIdentity::covers(self : OperatorIdentity, station : CommonAddress) -> Bool

    OperatorIdentity::display_name

    source
    fn OperatorIdentity::display_name(self : OperatorIdentity) -> String

    OperatorIdentity::id

    source
    fn OperatorIdentity::id(self : OperatorIdentity) -> String

    OperatorIdentity::new

    source
    fn OperatorIdentity::new(id : String, display_name : String, role : OperatorRole, stations? : Array[CommonAddress], active? : Bool) -> Result[OperatorIdentity, String]

    OperatorIdentity::role

    source

    OperatorIdentity::stations

    source

    OperatorRole

    source
    pub enum OperatorRole {
      ViewerRole
      EngineerRole
      DispatcherRole
      AdministratorRole
      ServiceRole
    } derive(Eq, 
    Debug    )

    Roles recognized by the operational authorization layer.

    OperatorRole::examples

    source
    fn OperatorRole::examples() -> Array[OperatorRole]

    Outstation

    source
    pub struct Outstation {
      common_address : Int
      single_points : Map[Int, Bool]
      normalized_values : Map[Int, Int]
    }

    A compact in-memory outstation used in tests, demos and protocol simulations.

    Outstation::new

    source
    fn Outstation::new(common_address : Int) -> Outstation

    Outstation::normalized

    source
    fn Outstation::normalized(self : Outstation, ioa : Int) -> Int?

    Outstation::set_normalized

    source
    fn Outstation::set_normalized(self : Outstation, ioa : Int, value : Int) -> Unit

    Outstation::set_single

    source
    fn Outstation::set_single(self : Outstation, ioa : Int, value : Bool) -> Unit

    Outstation::single

    source
    fn Outstation::single(self : Outstation, ioa : Int) -> Bool?

    Outstation::snapshot_normalized

    source
    fn Outstation::snapshot_normalized(self : Outstation) -> Array[PointSnapshot]

    Outstation::snapshot_single

    source
    fn Outstation::snapshot_single(self : Outstation) -> Array[PointSnapshot]

    PipelineResult

    source
    pub struct PipelineResult {
      sample : TelemetrySample
      accepted : Bool
      changed : Bool
      rate_valid : Bool
      alarms : Array[AlarmEvent]
      subscribers : Array[Int]
      message : String
    } derive(
    Debug    )

    Result of processing one application object.

    PipelineResult::accepted

    source
    fn PipelineResult::accepted(self : PipelineResult) -> Bool

    PipelineResult::alarms

    source

    PipelineResult::changed

    source
    fn PipelineResult::changed(self : PipelineResult) -> Bool

    PipelineResult::message

    source
    fn PipelineResult::message(self : PipelineResult) -> String

    PipelineResult::rate_valid

    source
    fn PipelineResult::rate_valid(self : PipelineResult) -> Bool

    PipelineResult::sample

    source

    PipelineResult::subscribers

    source
    fn PipelineResult::subscribers(self : PipelineResult) -> Array[Int]

    PointChange

    source
    pub struct PointChange {
      kind : PointChangeKind
      address : InformationAddress
      revision : Int
      timestamp : Int
      message : String
    } derive(Eq, 
    Debug    )

    PointChange::address

    source

    PointChange::kind

    source

    PointChange::message

    source
    fn PointChange::message(self : PointChange) -> String

    PointChange::new

    source
    fn PointChange::new(kind : PointChangeKind, address : InformationAddress, revision : Int, timestamp : Int, message : String) -> PointChange

    PointChange::revision

    source
    fn PointChange::revision(self : PointChange) -> Int

    PointChange::timestamp

    source
    fn PointChange::timestamp(self : PointChange) -> Int

    PointChangeKind

    source
    pub enum PointChangeKind {
      Inserted
      Updated
      Removed
      Rejected
    } derive(Eq, 
    Debug    )

    A change recorded by the point store.

    PointDirection

    source
    pub enum PointDirection {
      MonitorDirection
      ControlDirection
    } derive(Eq, 
    Debug    )

    Point direction used by a station data model.

    PointFilter

    source
    pub struct PointFilter {
      direction : PointDirection?
      type_id : ApplicationType?
      first_address : InformationAddress?
      last_address : InformationAddress?
      only_valid : Bool
      source : String?
    } derive(Eq, 
    Debug    )

    Query constraints for a point-store snapshot.

    PointFilter::all

    source

    PointFilter::control

    source
    fn PointFilter::control() -> PointFilter

    PointFilter::from_source

    source
    fn PointFilter::from_source(self : PointFilter, source : String) -> PointFilter

    PointFilter::monitoring

    source
    fn PointFilter::monitoring() -> PointFilter

    PointFilter::valid_only

    source
    fn PointFilter::valid_only(self : PointFilter) -> PointFilter

    PointFilter::with_range

    source
    fn PointFilter::with_range(self : PointFilter, first : InformationAddress, last : InformationAddress) -> PointFilter

    PointFilter::with_type

    source
    fn PointFilter::with_type(self : PointFilter, type_id : ApplicationType) -> PointFilter

    PointRecord

    source
    pub struct PointRecord {
      address : InformationAddress
      type_id : ApplicationType
      value : ApplicationValue
      time_tag : TimeTag?
      revision : Int
      updated_at : Int
      source : String
    } derive(Eq, 
    Debug    )

    A stored value with its protocol identity and update metadata.

    PointRecord::address

    source

    PointRecord::direction

    source
    fn PointRecord::direction(self : PointRecord) -> PointDirection

    PointRecord::is_valid

    source
    fn PointRecord::is_valid(self : PointRecord) -> Bool

    PointRecord::new

    source
    fn PointRecord::new(object : ApplicationObject, updated_at : Int, revision? : Int, source? : String) -> PointRecord

    PointRecord::revision

    source
    fn PointRecord::revision(self : PointRecord) -> Int

    PointRecord::source

    source
    fn PointRecord::source(self : PointRecord) -> String

    PointRecord::time_tag

    source
    fn PointRecord::time_tag(self : PointRecord) -> TimeTag?

    PointRecord::type_id

    source
    fn PointRecord::type_id(self : PointRecord) -> ApplicationType

    PointRecord::updated_at

    source
    fn PointRecord::updated_at(self : PointRecord) -> Int

    PointRecord::value

    source

    PointSnapshot

    source
    pub struct PointSnapshot {
      ioa : Int
      value : InformationObject
    }

    An immutable snapshot of values that can be used to build a response ASDU.

    PointStore

    source
    pub struct PointStore {
      common_address : CommonAddress
      points : Map[Int, PointRecord]
      history : Array[PointChange]
      history_limit : Int
    } derive(
    Debug    )

    Deterministic point store for outstations, simulators and gateways.

    PointStore::addresses

    source
    fn PointStore::addresses(self : PointStore) -> Array[InformationAddress]

    PointStore::common_address

    source
    fn PointStore::common_address(self : PointStore) -> CommonAddress

    PointStore::get

    source
    fn PointStore::get(self : PointStore, address : InformationAddress) -> PointRecord?

    PointStore::history

    source
    fn PointStore::history(self : PointStore) -> Array[PointChange]

    PointStore::history_len

    source
    fn PointStore::history_len(self : PointStore) -> Int

    PointStore::len

    source
    fn PointStore::len(self : PointStore) -> Int

    PointStore::new

    source
    fn PointStore::new(common_address : CommonAddress, history_limit? : Int) -> Result[PointStore, String]

    PointStore::objects

    source
    fn PointStore::objects(self : PointStore, filter : PointFilter) -> Array[ApplicationObject]

    Convert a store snapshot into application objects for interrogation.

    PointStore::query

    source
    fn PointStore::query(self : PointStore, filter : PointFilter) -> Array[PointRecord]

    PointStore::remove

    source
    fn PointStore::remove(self : PointStore, address : InformationAddress, timestamp : Int) -> Result[PointChange, Diagnostic]

    PointStore::statistics

    source
    fn PointStore::statistics(self : PointStore) -> StoreStatistics

    PointStore::upsert

    source
    fn PointStore::upsert(self : PointStore, object : ApplicationObject, timestamp : Int, source? : String) -> Result[PointChange, Diagnostic]

    PolicyAudit

    source
    pub struct PolicyAudit {
      sequence : Int
      timestamp : Int
      action : AuditAction
      operator : String
      station : CommonAddress?
      object : InformationAddress?
      allowed : Bool
      detail : String
    } derive(Eq, 
    Debug    )

    PolicyAudit::action

    source
    fn PolicyAudit::action(self : PolicyAudit) -> AuditAction

    PolicyAudit::allowed

    source
    fn PolicyAudit::allowed(self : PolicyAudit) -> Bool

    PolicyAudit::detail

    source
    fn PolicyAudit::detail(self : PolicyAudit) -> String

    PolicyAudit::object

    source

    PolicyAudit::operator

    source
    fn PolicyAudit::operator(self : PolicyAudit) -> String

    PolicyAudit::sequence

    source
    fn PolicyAudit::sequence(self : PolicyAudit) -> Int

    PolicyAudit::station

    source
    fn PolicyAudit::station(self : PolicyAudit) -> CommonAddress?

    PolicyAudit::timestamp

    source
    fn PolicyAudit::timestamp(self : PolicyAudit) -> Int

    PolicyAuditJournal

    source
    pub struct PolicyAuditJournal {
      entries : Array[PolicyAudit]
      limit : Int
      next_sequence : Int
    } derive(
    Debug    )

    Bounded audit journal shared by authorization and management APIs.

    PolicyAuditJournal::all

    source

    PolicyAuditJournal::append

    source
    fn PolicyAuditJournal::append(self : PolicyAuditJournal, timestamp : Int, action : AuditAction, operator : String, station : CommonAddress?, object : InformationAddress?, allowed : Bool, detail : String) -> PolicyAudit

    PolicyAuditJournal::len

    source
    fn PolicyAuditJournal::len(self : PolicyAuditJournal) -> Int

    PolicyAuditJournal::new

    source
    fn PolicyAuditJournal::new(limit? : Int) -> Result[PolicyAuditJournal, String]

    PolicyDecision

    source
    pub struct PolicyDecision {
      allowed : Bool
      permission : OperationalPermission
      operator : String
      station : CommonAddress
      rule_id : Int?
      reason : String
    } derive(Eq, 
    Debug    )

    PolicyDecision::allowed

    source
    fn PolicyDecision::allowed(self : PolicyDecision) -> Bool

    PolicyDecision::operator

    source
    fn PolicyDecision::operator(self : PolicyDecision) -> String

    PolicyDecision::permission

    source

    PolicyDecision::reason

    source
    fn PolicyDecision::reason(self : PolicyDecision) -> String

    PolicyDecision::rule_id

    source
    fn PolicyDecision::rule_id(self : PolicyDecision) -> Int?

    PolicyDecision::station

    source

    PolicyRule

    source
    pub struct PolicyRule {
      id : Int
      permission : OperationalPermission
      station : CommonAddress?
      type_ids : Array[ApplicationType]
      roles : Array[OperatorRole]
      enabled : Bool
      reason : String
    } derive(Eq, 
    Debug    )

    A station/type-specific policy rule.

    PolicyRule::disable

    source
    fn PolicyRule::disable(self : PolicyRule) -> Unit

    PolicyRule::enabled

    source
    fn PolicyRule::enabled(self : PolicyRule) -> Bool

    PolicyRule::id

    source
    fn PolicyRule::id(self : PolicyRule) -> Int

    PolicyRule::new

    source
    fn PolicyRule::new(id : Int, permission : OperationalPermission, reason : String, station? : CommonAddress, type_ids? : Array[ApplicationType], roles? : Array[OperatorRole]) -> Result[PolicyRule, String]

    PolicyRule::permission

    source
    fn PolicyRule::permission(self : PolicyRule) -> OperationalPermission

    PolicyRule::reason

    source
    fn PolicyRule::reason(self : PolicyRule) -> String

    PolicyRule::roles

    source
    fn PolicyRule::roles(self : PolicyRule) -> Array[OperatorRole]

    PolicyRule::station

    source
    fn PolicyRule::station(self : PolicyRule) -> CommonAddress?

    PolicyRule::type_ids

    source
    fn PolicyRule::type_ids(self : PolicyRule) -> Array[ApplicationType]

    ProfileRegistry

    source
    pub struct ProfileRegistry {
      profiles : Map[String, StationProfile]
    } derive(
    Debug    )

    ProfileRegistry::get

    source
    fn ProfileRegistry::get(self : ProfileRegistry, name : String) -> StationProfile?

    ProfileRegistry::len

    source
    fn ProfileRegistry::len(self : ProfileRegistry) -> Int

    ProfileRegistry::names

    source
    fn ProfileRegistry::names(self : ProfileRegistry) -> Array[String]

    ProfileRegistry::new

    source

    ProfileRegistry::put

    source
    fn ProfileRegistry::put(self : ProfileRegistry, profile : StationProfile) -> Result[Unit, String]

    ProfileRegistry::remove

    source
    fn ProfileRegistry::remove(self : ProfileRegistry, name : String) -> Bool

    ProfileRegistry::replace

    source
    fn ProfileRegistry::replace(self : ProfileRegistry, profile : StationProfile) -> Unit

    ProtocolEvent

    source
    pub enum ProtocolEvent {
      Connected
      Started
      Stopped
      Sent(Int)
      Received(Int)
      Acknowledged(Int)
      Fault(String)
    } derive(Eq, 
    Debug    )

    A protocol event useful for deterministic simulation and diagnostics.

    ProtocolRouter

    source
    pub struct ProtocolRouter {
      rules : Array[RoutingRule]
      queues : Map[Int, Array[RoutedObject]]
      queue_capacity : Int
      metrics : RouterMetrics
      sequence : Int
    } derive(
    Debug    )

    Address/type-aware router with bounded egress queues.

    ProtocolRouter::add_rule

    source
    fn ProtocolRouter::add_rule(self : ProtocolRouter, rule : RoutingRule) -> Result[Unit, String]

    ProtocolRouter::drain

    source
    fn ProtocolRouter::drain(self : ProtocolRouter, destination : Int, limit : Int) -> Array[RoutedObject]

    ProtocolRouter::evaluate

    source
    fn ProtocolRouter::evaluate(self : ProtocolRouter, source : Int, destination : Int, object : ApplicationObject) -> RouteDecision

    ProtocolRouter::metrics

    source

    ProtocolRouter::new

    source
    fn ProtocolRouter::new(queue_capacity? : Int) -> Result[ProtocolRouter, String]

    ProtocolRouter::queue_count

    source
    fn ProtocolRouter::queue_count(self : ProtocolRouter) -> Int

    ProtocolRouter::route

    source
    fn ProtocolRouter::route(self : ProtocolRouter, source : Int, destination : Int, object : ApplicationObject, timestamp : Int) -> Result[RouteDecision, Diagnostic]

    ProtocolRouter::rules

    source

    ProtocolTimers

    source
    pub struct ProtocolTimers {
      t0 : TimerState
      t1 : TimerState
      t2 : TimerState
      t3 : TimerState
    } derive(Eq, 
    Debug    )

    ProtocolTimers::expired

    source
    fn ProtocolTimers::expired(self : ProtocolTimers, now : Int) -> Array[String]

    ProtocolTimers::new

    source

    ProtocolTimers::start_t0

    source
    fn ProtocolTimers::start_t0(self : ProtocolTimers, deadline : Int) -> Unit

    ProtocolTimers::start_t1

    source
    fn ProtocolTimers::start_t1(self : ProtocolTimers, deadline : Int) -> Unit

    ProtocolTimers::start_t2

    source
    fn ProtocolTimers::start_t2(self : ProtocolTimers, deadline : Int) -> Unit

    ProtocolTimers::start_t3

    source
    fn ProtocolTimers::start_t3(self : ProtocolTimers, deadline : Int) -> Unit

    ProtocolTimers::stop_t0

    source
    fn ProtocolTimers::stop_t0(self : ProtocolTimers) -> Unit

    ProtocolTimers::stop_t1

    source
    fn ProtocolTimers::stop_t1(self : ProtocolTimers) -> Unit

    ProtocolTimers::stop_t2

    source
    fn ProtocolTimers::stop_t2(self : ProtocolTimers) -> Unit

    ProtocolTimers::stop_t3

    source
    fn ProtocolTimers::stop_t3(self : ProtocolTimers) -> Unit

    QualityDescriptor

    source
    pub struct QualityDescriptor {
      overflow : Bool
      blocked : Bool
      substituted : Bool
      not_topical : Bool
      invalid : Bool
    } derive(Eq, 
    Debug    )

    Quality descriptor shared by status and measurement objects.

    QualityDescriptor::clear

    source

    QualityDescriptor::flags

    source
    fn QualityDescriptor::flags(self : QualityDescriptor) -> Array[String]

    QualityDescriptor::from_byte

    source
    fn QualityDescriptor::from_byte(value : Int) -> Result[QualityDescriptor, String]

    Decode the low byte of a QDS value.

    QualityDescriptor::has_status_change

    source
    fn QualityDescriptor::has_status_change(self : QualityDescriptor) -> Bool

    QualityDescriptor::is_usable

    source
    fn QualityDescriptor::is_usable(self : QualityDescriptor) -> Bool

    QualityDescriptor::to_byte

    source
    fn QualityDescriptor::to_byte(self : QualityDescriptor) -> Int

    QualityDescriptor::with_blocked

    source
    fn QualityDescriptor::with_blocked(self : QualityDescriptor, value : Bool) -> QualityDescriptor

    QualityDescriptor::with_invalid

    source
    fn QualityDescriptor::with_invalid(self : QualityDescriptor, value : Bool) -> QualityDescriptor

    QualityDescriptor::with_not_topical

    source
    fn QualityDescriptor::with_not_topical(self : QualityDescriptor, value : Bool) -> QualityDescriptor

    QualityDescriptor::with_overflow

    source
    fn QualityDescriptor::with_overflow(self : QualityDescriptor, value : Bool) -> QualityDescriptor

    QualityDescriptor::with_substituted

    source
    fn QualityDescriptor::with_substituted(self : QualityDescriptor, value : Bool) -> QualityDescriptor

    QualityDisposition

    source
    pub enum QualityDisposition {
      QualityAccepted
      QualityDegraded
      QualityRejected
    } derive(Eq, 
    Debug    )

    Result applied when an incoming point violates an operational quality gate.

    QualityEvaluation

    source
    pub struct QualityEvaluation {
      station : CommonAddress?
      address : InformationAddress?
      disposition : QualityDisposition
      score : Int
      age : Int
      evaluated_at : Int
      rule_id : Int
      findings : Array[QualityFinding]
      message : String
    } derive(Eq, 
    Debug    )

    Evaluation of one point, including all reasons retained for audit.

    QualityEvaluation::accepted

    source
    fn QualityEvaluation::accepted(self : QualityEvaluation) -> Bool

    QualityEvaluation::address

    source

    QualityEvaluation::age

    source
    fn QualityEvaluation::age(self : QualityEvaluation) -> Int

    QualityEvaluation::disposition

    source

    QualityEvaluation::evaluated_at

    source
    fn QualityEvaluation::evaluated_at(self : QualityEvaluation) -> Int

    QualityEvaluation::finding_count

    source
    fn QualityEvaluation::finding_count(self : QualityEvaluation) -> Int

    QualityEvaluation::findings

    source

    QualityEvaluation::has_finding

    source
    fn QualityEvaluation::has_finding(self : QualityEvaluation, finding : QualityFinding) -> Bool

    QualityEvaluation::is_hard_failure

    source
    fn QualityEvaluation::is_hard_failure(self : QualityEvaluation) -> Bool

    QualityEvaluation::message

    source
    fn QualityEvaluation::message(self : QualityEvaluation) -> String

    QualityEvaluation::rule_id

    source
    fn QualityEvaluation::rule_id(self : QualityEvaluation) -> Int

    QualityEvaluation::score

    source
    fn QualityEvaluation::score(self : QualityEvaluation) -> Int

    QualityEvaluation::station

    source

    QualityEvaluation::summary_line

    source
    fn QualityEvaluation::summary_line(self : QualityEvaluation) -> String

    QualityEvaluation::worst_finding

    source

    QualityFinding

    source
    pub enum QualityFinding {
      QualityInvalidValue
      QualityStaleValue
      QualityFutureTimestamp
      QualityMissingSource
      QualityUnknownStation
      QualityControlBlocked
      QualityNoFinding
    } derive(Eq, 
    Debug    )

    Machine-readable findings retained in the quality audit stream.

    QualityGateRule

    source
    pub struct QualityGateRule {
      id : Int
      name : String
      max_age : Int
      future_skew : Int
      require_source : Bool
      reject_invalid : Bool
      reject_stale : Bool
      reject_future : Bool
      reject_control : Bool
      invalid_penalty : Int
      stale_penalty : Int
      future_penalty : Int
      missing_source_penalty : Int
      enabled : Bool
    } derive(Eq, 
    Debug    )

    A configurable quality gate for one station or an entire deployment.

    QualityGateRule::default_rule

    source
    fn QualityGateRule::default_rule() -> QualityGateRule

    QualityGateRule::enabled

    source
    fn QualityGateRule::enabled(self : QualityGateRule) -> Bool

    QualityGateRule::future_penalty

    source
    fn QualityGateRule::future_penalty(self : QualityGateRule) -> Int

    QualityGateRule::future_skew

    source
    fn QualityGateRule::future_skew(self : QualityGateRule) -> Int

    QualityGateRule::id

    source
    fn QualityGateRule::id(self : QualityGateRule) -> Int

    QualityGateRule::invalid_penalty

    source
    fn QualityGateRule::invalid_penalty(self : QualityGateRule) -> Int

    QualityGateRule::max_age

    source
    fn QualityGateRule::max_age(self : QualityGateRule) -> Int

    QualityGateRule::missing_source_penalty

    source
    fn QualityGateRule::missing_source_penalty(self : QualityGateRule) -> Int

    QualityGateRule::name

    source
    fn QualityGateRule::name(self : QualityGateRule) -> String

    QualityGateRule::new

    source
    fn QualityGateRule::new(id : Int, name : String, max_age? : Int, future_skew? : Int, require_source? : Bool, reject_invalid? : Bool, reject_stale? : Bool, reject_future? : Bool, reject_control? : Bool, invalid_penalty? : Int, stale_penalty? : Int, future_penalty? : Int, missing_source_penalty? : Int, enabled? : Bool) -> Result[QualityGateRule, String]

    QualityGateRule::reject_control

    source
    fn QualityGateRule::reject_control(self : QualityGateRule) -> Bool

    QualityGateRule::reject_future

    source
    fn QualityGateRule::reject_future(self : QualityGateRule) -> Bool

    QualityGateRule::reject_invalid

    source
    fn QualityGateRule::reject_invalid(self : QualityGateRule) -> Bool

    QualityGateRule::reject_stale

    source
    fn QualityGateRule::reject_stale(self : QualityGateRule) -> Bool

    QualityGateRule::require_source

    source
    fn QualityGateRule::require_source(self : QualityGateRule) -> Bool

    QualityGateRule::stale_penalty

    source
    fn QualityGateRule::stale_penalty(self : QualityGateRule) -> Int

    QualityGateRule::with_enabled

    source
    fn QualityGateRule::with_enabled(self : QualityGateRule, enabled : Bool) -> QualityGateRule

    QualityPolicyEngine

    source
    pub struct QualityPolicyEngine {
      rules : Map[Int, QualityGateRule]
      station_rules : Map[Int, Int]
      history : Array[QualityEvaluation]
      history_limit : Int
      metrics : QualityPolicyMetrics
    } derive(
    Debug    )

    Bounded policy engine keyed by rule id and station common address.

    QualityPolicyEngine::accepts_point

    source
    fn QualityPolicyEngine::accepts_point(self : QualityPolicyEngine, station : CommonAddress, record : PointRecord, now : Int) -> Bool

    QualityPolicyEngine::accepts_sample

    source
    fn QualityPolicyEngine::accepts_sample(self : QualityPolicyEngine, sample : TelemetrySample, now : Int) -> Bool

    QualityPolicyEngine::assign

    source
    fn QualityPolicyEngine::assign(self : QualityPolicyEngine, station : CommonAddress, rule_id : Int) -> Result[Unit, String]

    QualityPolicyEngine::assigned_rule

    source
    fn QualityPolicyEngine::assigned_rule(self : QualityPolicyEngine, station : CommonAddress) -> Int

    QualityPolicyEngine::assigned_stations

    source

    QualityPolicyEngine::audit_lines

    source
    fn QualityPolicyEngine::audit_lines(self : QualityPolicyEngine) -> Array[String]

    QualityPolicyEngine::clear_history

    source
    fn QualityPolicyEngine::clear_history(self : QualityPolicyEngine) -> Unit

    QualityPolicyEngine::enabled_rule_ids

    source
    fn QualityPolicyEngine::enabled_rule_ids(self : QualityPolicyEngine) -> Array[Int]

    QualityPolicyEngine::evaluate_object

    source
    fn QualityPolicyEngine::evaluate_object(self : QualityPolicyEngine, station : CommonAddress, object : ApplicationObject, source : String, timestamp : Int, now : Int) -> QualityEvaluation

    QualityPolicyEngine::evaluate_point

    source
    fn QualityPolicyEngine::evaluate_point(self : QualityPolicyEngine, station : CommonAddress, record : PointRecord, now : Int) -> QualityEvaluation

    QualityPolicyEngine::evaluate_records

    source
    fn QualityPolicyEngine::evaluate_records(self : QualityPolicyEngine, station : CommonAddress, records : Array[PointRecord], now : Int) -> QualityPolicyReport

    QualityPolicyEngine::evaluate_sample

    source
    fn QualityPolicyEngine::evaluate_sample(self : QualityPolicyEngine, sample : TelemetrySample, now : Int) -> QualityEvaluation

    QualityPolicyEngine::evaluate_store

    source
    fn QualityPolicyEngine::evaluate_store(self : QualityPolicyEngine, store : PointStore, now : Int) -> QualityPolicyReport

    QualityPolicyEngine::filter_accepted

    source

    QualityPolicyEngine::filter_rejected

    source

    QualityPolicyEngine::finding_counts

    source
    fn QualityPolicyEngine::finding_counts(_self : QualityPolicyEngine, evaluations : Array[QualityEvaluation]) -> Map[String, Int]

    QualityPolicyEngine::history

    source

    QualityPolicyEngine::history_len

    source
    fn QualityPolicyEngine::history_len(self : QualityPolicyEngine) -> Int

    QualityPolicyEngine::history_since

    source
    fn QualityPolicyEngine::history_since(self : QualityPolicyEngine, evaluated_at : Int) -> Array[QualityEvaluation]

    QualityPolicyEngine::metrics

    source

    QualityPolicyEngine::new

    source
    fn QualityPolicyEngine::new(history_limit? : Int) -> Result[QualityPolicyEngine, String]

    QualityPolicyEngine::register_rule

    source
    fn QualityPolicyEngine::register_rule(self : QualityPolicyEngine, rule : QualityGateRule) -> Result[Unit, String]

    QualityPolicyEngine::rejected_history

    source

    QualityPolicyEngine::remove_assignment

    source
    fn QualityPolicyEngine::remove_assignment(self : QualityPolicyEngine, station : CommonAddress) -> Bool

    QualityPolicyEngine::remove_rule

    source
    fn QualityPolicyEngine::remove_rule(self : QualityPolicyEngine, id : Int) -> Result[Unit, String]

    QualityPolicyEngine::replace_rule

    source
    fn QualityPolicyEngine::replace_rule(self : QualityPolicyEngine, rule : QualityGateRule) -> Result[Unit, String]

    QualityPolicyEngine::rule

    source

    QualityPolicyEngine::rule_ids

    source
    fn QualityPolicyEngine::rule_ids(self : QualityPolicyEngine) -> Array[Int]

    QualityPolicyEngine::rule_lines

    source
    fn QualityPolicyEngine::rule_lines(self : QualityPolicyEngine) -> Array[String]

    QualityPolicyEngine::snapshot

    source

    QualityPolicyEngine::station_rule

    source

    QualityPolicyEngine::stations_for_rule

    source
    fn QualityPolicyEngine::stations_for_rule(self : QualityPolicyEngine, rule_id : Int) -> Array[CommonAddress]

    QualityPolicyEngine::unassign

    source
    fn QualityPolicyEngine::unassign(self : QualityPolicyEngine, station : CommonAddress) -> Unit

    QualityPolicyEngine::validate_configuration

    source
    fn QualityPolicyEngine::validate_configuration(self : QualityPolicyEngine) -> Array[String]

    QualityPolicyMetrics

    source
    pub struct QualityPolicyMetrics {
      evaluated : Int
      accepted : Int
      degraded : Int
      rejected : Int
      invalid : Int
      stale : Int
      future : Int
      missing_source : Int
      control_blocked : Int
    } derive(Eq, 
    Debug    )

    Aggregate counters used by dashboards and acceptance reports.

    QualityPolicyMetrics::acceptance_percent

    source
    fn QualityPolicyMetrics::acceptance_percent(self : QualityPolicyMetrics) -> Int

    QualityPolicyMetrics::accepted

    source
    fn QualityPolicyMetrics::accepted(self : QualityPolicyMetrics) -> Int

    QualityPolicyMetrics::control_blocked

    source
    fn QualityPolicyMetrics::control_blocked(self : QualityPolicyMetrics) -> Int

    QualityPolicyMetrics::degraded

    source
    fn QualityPolicyMetrics::degraded(self : QualityPolicyMetrics) -> Int

    QualityPolicyMetrics::evaluated

    source
    fn QualityPolicyMetrics::evaluated(self : QualityPolicyMetrics) -> Int

    QualityPolicyMetrics::future

    source
    fn QualityPolicyMetrics::future(self : QualityPolicyMetrics) -> Int

    QualityPolicyMetrics::has_rejections

    source
    fn QualityPolicyMetrics::has_rejections(self : QualityPolicyMetrics) -> Bool

    QualityPolicyMetrics::invalid

    source
    fn QualityPolicyMetrics::invalid(self : QualityPolicyMetrics) -> Int

    QualityPolicyMetrics::missing_source

    source
    fn QualityPolicyMetrics::missing_source(self : QualityPolicyMetrics) -> Int

    QualityPolicyMetrics::new

    source

    QualityPolicyMetrics::quality_percent

    source
    fn QualityPolicyMetrics::quality_percent(self : QualityPolicyMetrics) -> Int

    QualityPolicyMetrics::rejected

    source
    fn QualityPolicyMetrics::rejected(self : QualityPolicyMetrics) -> Int

    QualityPolicyMetrics::stale

    source

    QualityPolicyMetrics::total_findings

    source
    fn QualityPolicyMetrics::total_findings(self : QualityPolicyMetrics) -> Int

    QualityPolicyReport

    source
    pub struct QualityPolicyReport {
      total : Int
      accepted : Int
      degraded : Int
      rejected : Int
      evaluations : Array[QualityEvaluation]
    } derive(
    Debug    )

    Summary returned after evaluating a point-store snapshot.

    QualityPolicyReport::accepted

    source
    fn QualityPolicyReport::accepted(self : QualityPolicyReport) -> Int

    QualityPolicyReport::degraded

    source
    fn QualityPolicyReport::degraded(self : QualityPolicyReport) -> Int

    QualityPolicyReport::evaluations

    source

    QualityPolicyReport::has_rejections

    source
    fn QualityPolicyReport::has_rejections(self : QualityPolicyReport) -> Bool

    QualityPolicyReport::quality_percent

    source
    fn QualityPolicyReport::quality_percent(self : QualityPolicyReport) -> Int

    QualityPolicyReport::rejected

    source
    fn QualityPolicyReport::rejected(self : QualityPolicyReport) -> Int

    QualityPolicyReport::total

    source
    fn QualityPolicyReport::total(self : QualityPolicyReport) -> Int

    QualityPolicySnapshot

    source
    pub struct QualityPolicySnapshot {
      rule_count : Int
      assignment_count : Int
      history_count : Int
      metrics : QualityPolicyMetrics
      configuration_issues : Array[String]
    } derive(
    Debug    )

    QualityPolicySnapshot::assignment_count

    source
    fn QualityPolicySnapshot::assignment_count(self : QualityPolicySnapshot) -> Int

    QualityPolicySnapshot::configuration_issues

    source
    fn QualityPolicySnapshot::configuration_issues(self : QualityPolicySnapshot) -> Array[String]

    QualityPolicySnapshot::history_count

    source
    fn QualityPolicySnapshot::history_count(self : QualityPolicySnapshot) -> Int

    QualityPolicySnapshot::metrics

    source

    QualityPolicySnapshot::rule_count

    source
    fn QualityPolicySnapshot::rule_count(self : QualityPolicySnapshot) -> Int

    RateLimiter

    source
    pub struct RateLimiter {
      window_start : Int
      window_size : Int
      limit : Int
      used : Int
    } derive(Eq, 
    Debug    )

    A fixed-window rate limiter for commands and diagnostics.

    RateLimiter::allow

    source
    fn RateLimiter::allow(self : RateLimiter, now : Int) -> Bool

    RateLimiter::new

    source
    fn RateLimiter::new(window_size : Int, limit : Int) -> Result[RateLimiter, String]

    RateLimiter::remaining

    source
    fn RateLimiter::remaining(self : RateLimiter) -> Int

    RateLimiter::used

    source
    fn RateLimiter::used(self : RateLimiter) -> Int

    RateRule

    source
    pub struct RateRule {
      maximum_per_second : Float
      minimum_interval : Int
    } derive(Eq, 
    Debug    )

    Rate-of-change rule for detecting stale or physically implausible updates.

    RateRule::maximum_per_second

    source
    fn RateRule::maximum_per_second(self : RateRule) -> Float

    RateRule::minimum_interval

    source
    fn RateRule::minimum_interval(self : RateRule) -> Int

    RateRule::new

    source
    fn RateRule::new(maximum_per_second : Float, minimum_interval? : Int) -> Result[RateRule, String]

    RateRule::within

    source
    fn RateRule::within(self : RateRule, previous : TelemetrySample, current : TelemetrySample) -> Bool

    ReadTransaction

    source
    pub struct ReadTransaction {
      request : ServiceRequest
      status : ServiceStatus
    } derive(
    Debug    )

    Read service state for a single information object.

    ReadTransaction::activate

    source
    fn ReadTransaction::activate(self : ReadTransaction) -> Result[Unit, String]

    ReadTransaction::complete

    source
    fn ReadTransaction::complete(self : ReadTransaction, object : ApplicationObject) -> Result[ServiceResponse, String]

    ReadTransaction::new

    source
    fn ReadTransaction::new(request : ServiceRequest) -> Result[ReadTransaction, String]

    ReadTransaction::reject

    source
    fn ReadTransaction::reject(self : ReadTransaction, message : String) -> ServiceResponse

    ReadTransaction::status

    source

    RedundancyManager

    source
    pub struct RedundancyManager {
      station : CommonAddress
      peers : Map[Int, RedundantPeer]
      events : Array[FailoverEvent]
      event_limit : Int
      policy : RedundancyPolicy
      owner : Int?
      last_takeover : Int
      fencing_token : Int
      metrics : RedundancyMetrics
    } derive(
    Debug    )

    Deterministic primary/standby ownership manager.

    RedundancyManager::add_peer

    source
    fn RedundancyManager::add_peer(self : RedundancyManager, peer : RedundantPeer) -> Result[Unit, String]

    RedundancyManager::elect

    source
    fn RedundancyManager::elect(self : RedundancyManager, now : Int) -> Result[FailoverEvent?, String]

    RedundancyManager::events

    source

    RedundancyManager::fencing_token

    source
    fn RedundancyManager::fencing_token(self : RedundancyManager) -> Int

    RedundancyManager::heartbeat

    source
    fn RedundancyManager::heartbeat(self : RedundancyManager, id : Int, now : Int) -> Result[LinkHealth, String]

    RedundancyManager::manual_takeover

    source
    fn RedundancyManager::manual_takeover(self : RedundancyManager, id : Int, now : Int) -> Result[FailoverEvent, String]

    </