🥮 mooncakes.io
README

wcx789ll/moonsim/core/clock does not have a README file

#
Clock

source
pub(all) struct Clock {
  time : SimTime
  next_seq : Int64
  heap : EventHeap
  status : ClockStatus
  target_time : Double?
} derive(
Debug)

#
Clock::active_count

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

#
Clock::cancel

source
fn Clock::cancel(self : Clock, id : EventId) -> Bool

#
Clock::filter_events

source
fn Clock::filter_events(self : Clock, predicate : (PriorityEvent) -> Bool) -> Int

#
Clock::get_event

source
fn Clock::get_event(self : Clock, id : EventId) -> PriorityEvent?

#
Clock::new

source
fn Clock::new() -> Clock

#
Clock::next_event

source
fn Clock::next_event(self : Clock) -> PriorityEvent?

#
Clock::now

source
fn Clock::now(self : Clock) -> SimTime

#
Clock::now_seconds

source
fn Clock::now_seconds(self : Clock) -> Double

#
Clock::reset

source
fn Clock::reset(self : Clock) -> Unit

#
Clock::schedule

source
fn Clock::schedule(self : Clock, delta_seconds : Double, priority : Int, payload_id : Int) -> EventId

#
Clock::schedule_at

source
fn Clock::schedule_at(self : Clock, target : SimTime, priority : Int, payload_id : Int) -> EventId

#
Clock::set_target_time

source
fn Clock::set_target_time(self : Clock, limit_seconds : Double?) -> Unit

#
Clock::status

source
fn Clock::status(self : Clock) -> ClockStatus

#
ClockStatus

source
pub(all) enum ClockStatus {
  Idle
  Running
  Paused
  Completed
} derive(Eq, 
Debug)

#
EventHeap

source
pub(all) struct EventHeap {
  // private fields
} derive(
Debug)

#
EventHeap::active_count

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

#
EventHeap::cancel_by_id

source
fn EventHeap::cancel_by_id(self : EventHeap, target_id : EventId) -> Bool

#
EventHeap::clear

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

#
EventHeap::filter_events

source
fn EventHeap::filter_events(self : EventHeap, predicate : (PriorityEvent) -> Bool) -> Int

#
EventHeap::get_event_by_id

source
fn EventHeap::get_event_by_id(self : EventHeap, target_id : EventId) -> PriorityEvent?

#
EventHeap::is_empty

source
fn EventHeap::is_empty(self : EventHeap) -> Bool

#
EventHeap::new

source
fn EventHeap::new() -> EventHeap

#
EventHeap::peek

source
fn EventHeap::peek(self : EventHeap) -> PriorityEvent?

#
EventHeap::pop

source
fn EventHeap::pop(self : EventHeap) -> PriorityEvent?

#
EventHeap::push

source
fn EventHeap::push(self : EventHeap, event : PriorityEvent) -> Unit

#
EventHeap::size

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

#
EventId

source
pub(all) struct EventId {
  seq : Int64
} derive(Eq, 
Debug)

#
EventId::compare

source
fn EventId::compare(self : EventId, other : EventId) -> Int

#
PriorityEvent

source
pub(all) struct PriorityEvent {
  time : SimTime
  priority : Int
  id : EventId
  cancelled : Bool
  payload_id : Int
} derive(
Debug)

#
PriorityEvent::compare

source
fn PriorityEvent::compare(self : PriorityEvent, other : PriorityEvent) -> Int

#
SimTime

source
pub(all) struct SimTime {
  val : Double
} derive(Eq, 
Debug)

#
SimTime::compare

source
fn SimTime::compare(self : SimTime, other : SimTime) -> Int

#
SimTime::from_seconds

source
fn SimTime::from_seconds(sec : Double) -> SimTime

#
SimTime::op_add

source
fn SimTime::op_add(self : SimTime, delta : Double) -> SimTime

#
SimTime::to_seconds

source
fn SimTime::to_seconds(self : SimTime) -> Double

#
SimTime::zero

source
fn SimTime::zero() -> SimTime

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io