WEICZ20/moonbit-computer-interlocking/src/interlocking does not have a README file

    ActiveRouteState

    pub(all) struct ActiveRouteState {
    rule : InterlockingRule
    state : RouteState
    release_stage : ReleaseStage
    unlocked_sections : FixedArray[Bool]
    occupied_sections : FixedArray[Bool]
    highest_observed_section_index : Int
    occupancy_order_violation : Bool
    observed_train_id : String
    entry_time_ms : Int64
    } derive(
    Debug
    )

    ActiveRouteState::new

    InterlockingTable

    pub(all) struct InterlockingTable {
    rules : Map[Int, InterlockingRule]
    active_routes : Map[Int, ActiveRouteState]
    active_route_flags : FixedArray[Bool]
    signal_pair_index : Map[Int, RouteId]
    track_to_routes : Map[Int, Array[RouteId]]
    turnout_to_routes : Map[Int, Array[RouteId]]
    acquired_turnout_scratch : FixedArray[
    TurnoutId
    ]
    acquired_track_scratch : FixedArray[
    TrackId
    ]
    acquired_turnout_count : Int
    acquired_track_count : Int
    next_route_id : Int
    } derive(
    Debug
    )

    InterlockingTable::active_slot_count

    fn InterlockingTable::active_slot_count(self : InterlockingTable) -> Int

    InterlockingTable::cancel_route

    fn InterlockingTable::cancel_route(self : InterlockingTable, station :
    Station
    , route_id : RouteId) -> Result[Unit, String]

    InterlockingTable::enforce_emergency_fail_safe

    InterlockingTable::get_active_route

    fn InterlockingTable::get_active_route(self : InterlockingTable, route_id : RouteId) -> ActiveRouteState?

    InterlockingTable::get_routes_by_track

    InterlockingTable::get_rule

    fn InterlockingTable::get_rule(self : InterlockingTable, route_id : RouteId) -> InterlockingRule?

    InterlockingTable::is_active_slot

    fn InterlockingTable::is_active_slot(self : InterlockingTable, slot : Int) -> Bool

    InterlockingTable::is_route_active

    fn InterlockingTable::is_route_active(self : InterlockingTable, route_id : RouteId) -> Bool

    InterlockingTable::is_route_reserved

    fn InterlockingTable::is_route_reserved(self : InterlockingTable, route_id : RouteId) -> Bool

    InterlockingTable::new

    InterlockingTable::process_sectional_release

    InterlockingTable::process_sectional_release_fast

    InterlockingTable::request_and_lock_route

    InterlockingTable::request_and_lock_route_fast

    fn InterlockingTable::request_and_lock_route_fast(self : InterlockingTable, station :
    Station
    , route_id : RouteId) -> Bool

    InterlockingTable::scan_safety_summary

    InterlockingTable::validate_active_route_lifecycle

    InterlockingTable::verify_all_safety_invariants

    ReleaseCounters

    pub(all) struct ReleaseCounters {
    sections_unlocked : Int
    switches_unlocked : Int
    is_route_completed : Bool
    entered_route : Bool
    } derive(
    Debug
    )

    ReleaseStage

    pub(all) enum ReleaseStage {
    StageNotStarted
    StageApproachOccupied
    StageEntrySectionOccupied
    StageMiddleSectionOccupied
    StageExitSectionOccupied
    StageFullyReleased
    } derive(Eq,
    Debug
    )

    RouteId

    pub(all) struct RouteId {
    id : Int
    } derive(Compare, Eq,
    Debug
    )

    RouteId::new

    fn RouteId::new(id : Int) -> RouteId

    RouteLifecycleAudit

    pub(all) struct RouteLifecycleAudit {
    route_id : RouteId
    is_valid : Bool
    transition_count : Int
    errors : Array[String]
    } derive(
    Debug
    )

    RouteLockResult

    pub(all) struct RouteLockResult {
    is_success : Bool
    route_id : RouteId
    message : String
    } derive(
    Debug
    )

    RouteState

    pub(all) enum RouteState {
    RouteInactive
    RouteRequested
    SwitchesThrowing
    RouteLocked
    ApproachLocked
    TrainInRoute
    SectionalUnlocking
    RouteCancelling
    RouteFault
    } derive(Eq,
    Debug
    )

    RouteState::to_string

    fn RouteState::to_string(self : RouteState) -> String

    RouteType

    pub(all) enum RouteType {
    ReceivingRoute
    DepartureRoute
    PassingRoute
    ShuntingRoute
    } derive(Eq,
    Debug
    )

    RouteType::to_string

    fn RouteType::to_string(self : RouteType) -> String

    SafetyAuditReport

    pub(all) struct SafetyAuditReport {
    violations : Array[SafetyViolation]
    fatal_count : Int
    warning_count : Int
    can_clear_signal : Bool
    } derive(
    Debug
    )

    SafetyAuditReport::contains_kind

    fn SafetyAuditReport::contains_kind(self : SafetyAuditReport, kind : SafetyViolationKind) -> Bool

    SafetyAuditReport::new

    SafetyAuditReport::violations

    SafetyInvariantViolation

    pub(all) struct SafetyInvariantViolation {
    violation_type : String
    description : String
    affected_route_id : RouteId?
    } derive(
    Debug
    )

    SafetySeverity

    pub(all) enum SafetySeverity {
    SafetyWarning
    SafetyCritical
    SafetyEmergency
    } derive(Eq,
    Debug
    )

    SafetySeverity::is_fatal

    fn SafetySeverity::is_fatal(self : SafetySeverity) -> Bool

    SafetySeverity::to_string

    fn SafetySeverity::to_string(self : SafetySeverity) -> String

    SafetyViolation

    pub(all) struct SafetyViolation {
    kind : SafetyViolationKind
    severity : SafetySeverity
    affected_route_id : RouteId?
    description : String
    } derive(
    Debug
    )

    SafetyViolation::new

    fn SafetyViolation::new(kind : SafetyViolationKind, severity : SafetySeverity, affected_route_id : RouteId?, description : String) -> SafetyViolation

    SafetyViolation::to_string

    fn SafetyViolation::to_string(self : SafetyViolation) -> String

    SafetyViolationKind

    pub(all) enum SafetyViolationKind {
    MissingTurnout
    TurnoutPositionMismatch
    TurnoutUnlocked
    FlankProtectionMismatch
    HostileRouteConflict
    MissingTrack
    FaultedRouteSection
    ProceedSignalUnsafe
    FaultSignalNotRed
    ReleaseBeforeTraversal
    OccupancyOrderViolation
    IllegalRouteTransition
    } derive(Eq,
    Debug
    )

    SafetyViolationKind::to_string

    fn SafetyViolationKind::to_string(self : SafetyViolationKind) -> String

    ScanSafetySummary

    pub(all) struct ScanSafetySummary {
    checked_routes : Int
    fatal_count : Int
    warning_count : Int
    can_clear_signal : Bool
    } derive(
    Debug
    )

    SectionalReleaseResult

    pub(all) struct SectionalReleaseResult {
    sections_unlocked : Array[
    TrackId
    ]
    switches_unlocked : Array[
    TurnoutId
    ]
    is_route_completed : Bool
    } derive(
    Debug
    )

    determine_signal_aspect_for_route

    update_distant_signal_linkage

    fn update_distant_signal_linkage(station :
    Station
    , linkage : DistantSignalLinkage) -> Result[Unit, String]

    validate_route_transition

    fn validate_route_transition(from : RouteState, to : RouteState) -> Result[Unit, String]