🥮 mooncakes.io

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

    EdgeId

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

    EdgeId::new

    source
    fn EdgeId::new(id : Int) -> EdgeId

    GraphPath

    source
    pub(all) struct GraphPath {
      nodes : Array[NodeId]
      edges : Array[EdgeId]
      tracks : Array[TrackId]
      total_distance : Double
    } derive(
    Debug    )

    GraphPath::empty

    source
    fn GraphPath::empty() -> GraphPath

    GraphPath::is_valid

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

    NodeId

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

    NodeId::new

    source
    fn NodeId::new(id : Int) -> NodeId

    NodeType

    source
    pub(all) enum NodeType {
      TrackNode
      TurnoutBaseNode
      TurnoutNormalNode
      TurnoutReverseNode
      SignalNode
      BoundaryNode
    } derive(Eq, 
    Debug    )

    Signal

    source
    pub(all) struct Signal {
      id : SignalId
      name : String
      signal_type : SignalType
      current_aspect : SignalAspect
      requested_aspect : SignalAspect
      is_locked : Bool
      bound_node : NodeId
      direction : TrackDirection
    } derive(
    Debug    )

    Signal::new

    source
    fn Signal::new(id : SignalId, name : String, signal_type : SignalType, bound_node : NodeId, direction : TrackDirection) -> Signal

    SignalAspect

    source
    pub(all) enum SignalAspect {
      Red
      Yellow
      Green
      DoubleYellow
      YellowGreen
      Blue
      White
      FlashingYellow
      Dark
    } derive(Eq, 
    Debug    )

    SignalAspect::is_proceed

    source
    fn SignalAspect::is_proceed(self : SignalAspect) -> Bool

    SignalAspect::to_string

    source
    fn SignalAspect::to_string(self : SignalAspect) -> String

    SignalId

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

    SignalId::new

    source
    fn SignalId::new(id : Int) -> SignalId

    SignalType

    source
    pub(all) enum SignalType {
      HomeSignal
      ExitSignal
      ShuntingSignal
      DistantSignal
      RouteSignal
      BlockSignal
    } derive(Eq, 
    Debug    )

    SignalType::to_string

    source
    fn SignalType::to_string(self : SignalType) -> String

    Station

    source
    pub(all) struct Station {
      name : String
      graph : StationGraph
      next_node_id : Int
      next_edge_id : Int
      next_track_id : Int
      next_turnout_id : Int
      next_signal_id : Int
    } derive(
    Debug    )

    Station::create_node

    source
    fn Station::create_node(self : Station, name : String, node_type : NodeType) -> NodeId

    Station::create_signal

    source
    fn Station::create_signal(self : Station, name : String, signal_type : SignalType, bound_node : NodeId, direction : TrackDirection) -> SignalId

    Station::create_track

    source
    fn Station::create_track(self : Station, name : String, length : Double, speed : Double, start_node : NodeId, end_node : NodeId, direction : TrackDirection) -> TrackId

    Station::create_turnout

    source
    fn Station::create_turnout(self : Station, name : String, base_node : NodeId, normal_next_node : NodeId, reverse_next_node : NodeId) -> TurnoutId

    Station::lock_signal

    source
    fn Station::lock_signal(self : Station, s_id : SignalId) -> Result[Unit, String]

    Station::lock_turnout

    source
    fn Station::lock_turnout(self : Station, t_id : TurnoutId) -> Result[Unit, String]

    Station::new

    source
    fn Station::new(name : String) -> Station

    Station::set_signal_aspect

    source
    fn Station::set_signal_aspect(self : Station, s_id : SignalId, aspect : SignalAspect) -> Result[Unit, String]

    Station::set_track_state

    source
    fn Station::set_track_state(self : Station, tr_id : TrackId, state : TrackState, train_id : String) -> Result[Unit, String]

    Station::set_turnout_position

    source
    fn Station::set_turnout_position(self : Station, t_id : TurnoutId, pos : TurnoutPosition) -> Result[Unit, String]

    Station::unlock_signal

    source
    fn Station::unlock_signal(self : Station, s_id : SignalId) -> Result[Unit, String]

    Station::unlock_turnout

    source
    fn Station::unlock_turnout(self : Station, t_id : TurnoutId) -> Result[Unit, String]

    Station::validate_operational_topology

    source
    fn Station::validate_operational_topology(self : Station) -> TopologyValidationReport

    StationGraph

    source
    pub(all) struct StationGraph {
      nodes : Map[Int, TopologyNode]
      edges : Map[Int, TopologyEdge]
      adjacency : Map[Int, Array[EdgeId]]
      reverse_adjacency : Map[Int, Array[EdgeId]]
      tracks : Map[Int, TrackSegment]
      turnouts : Map[Int, Turnout]
      signals : Map[Int, Signal]
    } derive(
    Debug    )

    StationGraph::add_edge

    source
    fn StationGraph::add_edge(self : StationGraph, edge : TopologyEdge) -> Unit

    StationGraph::add_node

    source
    fn StationGraph::add_node(self : StationGraph, node : TopologyNode) -> Unit

    StationGraph::add_signal

    source
    fn StationGraph::add_signal(self : StationGraph, signal : Signal) -> Unit

    StationGraph::add_track

    source
    fn StationGraph::add_track(self : StationGraph, track : TrackSegment) -> Unit

    StationGraph::add_turnout

    source
    fn StationGraph::add_turnout(self : StationGraph, turnout : Turnout) -> Unit

    StationGraph::find_all_paths

    source
    fn StationGraph::find_all_paths(self : StationGraph, start : NodeId, target : NodeId, max_depth : Int) -> Array[GraphPath]

    StationGraph::get_edge

    source
    fn StationGraph::get_edge(self : StationGraph, id : EdgeId) -> TopologyEdge?

    StationGraph::get_in_edges

    source
    fn StationGraph::get_in_edges(self : StationGraph, node_id : NodeId) -> Array[TopologyEdge]

    StationGraph::get_node

    source
    fn StationGraph::get_node(self : StationGraph, id : NodeId) -> TopologyNode?

    StationGraph::get_out_edges

    source
    fn StationGraph::get_out_edges(self : StationGraph, node_id : NodeId) -> Array[TopologyEdge]

    StationGraph::get_signal

    source
    fn StationGraph::get_signal(self : StationGraph, id : SignalId) -> Signal?

    StationGraph::get_track

    source
    fn StationGraph::get_track(self : StationGraph, id : TrackId) -> TrackSegment?

    StationGraph::get_turnout

    source
    fn StationGraph::get_turnout(self : StationGraph, id : TurnoutId) -> Turnout?

    StationGraph::is_turnout_path_active

    source
    fn StationGraph::is_turnout_path_active(self : StationGraph, from_node : NodeId, to_node : NodeId) -> Bool

    StationGraph::new

    source

    StationGraph::validate_topology

    source
    fn StationGraph::validate_topology(self : StationGraph) -> Array[String]

    TopologyBuilder

    source
    pub(all) struct TopologyBuilder {
      station : Station
    } derive(
    Debug    )

    TopologyBuilder::add_signal_at

    source
    fn TopologyBuilder::add_signal_at(self : TopologyBuilder, name : String, signal_type : SignalType, node_name : String, direction : TrackDirection) -> SignalId

    TopologyBuilder::add_track_section

    source
    fn TopologyBuilder::add_track_section(self : TopologyBuilder, name : String, length : Double, speed : Double, start_name : String, end_name : String, direction : TrackDirection) -> TrackId

    TopologyBuilder::add_turnout_node

    source
    fn TopologyBuilder::add_turnout_node(self : TopologyBuilder, name : String, base_name : String, normal_name : String, reverse_name : String) -> TurnoutId

    TopologyBuilder::build

    source

    TopologyBuilder::new

    source
    fn TopologyBuilder::new(station_name : String) -> TopologyBuilder

    TopologyEdge

    source
    pub(all) struct TopologyEdge {
      id : EdgeId
      from_node : NodeId
      to_node : NodeId
      track_id : TrackId
      weight : Double
      direction : TrackDirection
    } derive(
    Debug    )

    TopologyEdge::new

    source
    fn TopologyEdge::new(id : EdgeId, from_node : NodeId, to_node : NodeId, track_id : TrackId, weight : Double, direction : TrackDirection) -> TopologyEdge

    TopologyIssue

    source
    pub(all) struct TopologyIssue {
      kind : TopologyIssueKind
      resource : String
      detail : String
    } derive(
    Debug    )

    TopologyIssue::new

    source
    fn TopologyIssue::new(kind : TopologyIssueKind, resource : String, detail : String) -> TopologyIssue

    TopologyIssue::to_string

    source
    fn TopologyIssue::to_string(self : TopologyIssue) -> String

    TopologyIssueKind

    source
    pub(all) enum TopologyIssueKind {
      OrphanNode
      MissingTrackEndpoint
      InvalidTrackGeometry
      MissingTrackEdge
      InvalidTurnoutReference
      InvalidSignalBinding
    } derive(Eq, 
    Debug    )

    TopologyIssueKind::to_string

    source
    fn TopologyIssueKind::to_string(self : TopologyIssueKind) -> String

    TopologyNode

    source
    pub(all) struct TopologyNode {
      id : NodeId
      name : String
      node_type : NodeType
      associated_turnout : TurnoutId?
      associated_signal : SignalId?
      associated_track : TrackId?
    } derive(
    Debug    )

    TopologyNode::new

    source
    fn TopologyNode::new(id : NodeId, name : String, node_type : NodeType) -> TopologyNode

    TopologyValidationReport

    source
    pub(all) struct TopologyValidationReport {
      issues : Array[TopologyIssue]
      error_count_value : Int
    } derive(
    Debug    )

    TopologyValidationReport::error_count

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

    TopologyValidationReport::is_valid

    source

    TopologyValidationReport::issues

    source

    TopologyValidationReport::new

    source

    TrackDirection

    source
    pub(all) enum TrackDirection {
      UpTrack
      DownTrack
      BiDirectional
    } derive(Eq, 
    Debug    )

    TrackDirection::to_string

    source
    fn TrackDirection::to_string(self : TrackDirection) -> String

    TrackId

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

    TrackId::new

    source
    fn TrackId::new(id : Int) -> TrackId

    TrackSegment

    source
    pub(all) struct TrackSegment {
      id : TrackId
      name : String
      length_meters : Double
      speed_limit_kmh : Double
      start_node : NodeId
      end_node : NodeId
      direction : TrackDirection
      state : TrackState
      occupying_train_id : String
    } derive(
    Debug    )

    TrackSegment::new

    source
    fn TrackSegment::new(id : TrackId, name : String, length_meters : Double, speed_limit_kmh : Double, start_node : NodeId, end_node : NodeId, direction : TrackDirection) -> TrackSegment

    TrackState

    source
    pub(all) enum TrackState {
      Clear
      Occupied
      Locked
      Fault
    } derive(Eq, 
    Debug    )

    TrackState::to_string

    source
    fn TrackState::to_string(self : TrackState) -> String

    Turnout

    source
    pub(all) struct Turnout {
      id : TurnoutId
      name : String
      position : TurnoutPosition
      target_position : TurnoutPosition
      is_locked : Bool
      is_in_fault : Bool
      normal_next_node : NodeId
      reverse_next_node : NodeId
      base_node : NodeId
    } derive(
    Debug    )

    Turnout::new

    source
    fn Turnout::new(id : TurnoutId, name : String, base_node : NodeId, normal_next_node : NodeId, reverse_next_node : NodeId) -> Turnout

    TurnoutId

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

    TurnoutId::new

    source
    fn TurnoutId::new(id : Int) -> TurnoutId

    TurnoutPosition

    source
    pub(all) enum TurnoutPosition {
      Normal
      Reverse
      Moving
      UnknownPosition
    } derive(Eq, 
    Debug    )

    TurnoutPosition::to_string

    source
    fn TurnoutPosition::to_string(self : TurnoutPosition) -> String

    legacy_create_track_helper

    source
    fn legacy_create_track_helper(station : Station, name : String, length : Double, start_node : NodeId, end_node : NodeId) -> TrackId

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io