README

mokomoking2501/lockwire/clock does not have a README file

#
SimInstant

type SimInstant = Instant[SimTruth]

#
CrossStamper

pub(open) trait CrossStamper {
fn cross_stamp(Self) -> DomainCrossStamp
}

#
MonotonicClock

pub(open) trait MonotonicClock {
fn now(Self) -> DomainInstant
fn domain(Self) -> DomainId
fn resolution(Self) ->
Duration

}

#
TimerDriver

pub(open) trait TimerDriver {
fn sleep_until(Self, DomainInstant) -> Unit
}

#
ClockRelation

pub struct ClockRelation[A, B] {
// private fields
}

#
ClockRelation::bound

#
ClockRelation::convert

fn[A, B] ClockRelation::convert(self : ClockRelation[A, B], instant : Instant[A]) -> Uncertain[Instant[B]]

#
ClockRelation::new

fn[A, B] ClockRelation::new(source_domain~ : DomainId, target_domain~ : DomainId, offset~ :
Duration
, rate_ppb~ : Int64, bound~ :
Duration
, asof~ : Instant[A]) -> ClockRelation[A, B]

#
ClockRelation::source_domain

fn[A, B] ClockRelation::source_domain(self : ClockRelation[A, B]) -> DomainId

#
ClockRelation::target_domain

fn[A, B] ClockRelation::target_domain(self : ClockRelation[A, B]) -> DomainId

#
CrossStamp

pub(all) struct CrossStamp[A, B] {
source : Instant[A]
target : Instant[B]
bound :
Duration

}

#
DcDomain

pub(all) enum DcDomain {
DcDomain
} derive(Eq,
Debug
)

#
DomainCrossStamp

pub(all) struct DomainCrossStamp {
source : DomainInstant
target : DomainInstant
bound :
Duration

} derive(Eq,
Debug
)

#
DomainId

pub(all) enum DomainId {
DomainId(String)
} derive(Eq,
Debug
)

#
DomainId::name

fn DomainId::name(self : DomainId) -> String

#
DomainId::new

fn DomainId::new(name~ : String) -> DomainId

#
DomainInstant

pub(all) struct DomainInstant {
domain : DomainId
ns : Int64
} derive(Eq,
Debug
)

#
DomainInstant::domain

fn DomainInstant::domain(self : DomainInstant) -> DomainId

#
DomainInstant::from_typed

fn[D] DomainInstant::from_typed(instant : Instant[D]) -> DomainInstant

#
DomainInstant::new

fn DomainInstant::new(domain~ : DomainId, ns~ : Int64) -> DomainInstant

#
DomainInstant::ns

fn DomainInstant::ns(self : DomainInstant) -> Int64

#
Instant

pub struct Instant[D] {
// private fields
}

#
Instant::add

#
Instant::domain

fn[D] Instant::domain(self : Instant[D]) -> DomainId

#
Instant::duration_since

fn[D] Instant::duration_since(self : Instant[D], earlier : Instant[D]) ->
Duration

#
Instant::equals

fn[D] Instant::equals(self : Instant[D], other : Instant[D]) -> Bool

#
Instant::new

fn[D] Instant::new(domain~ : DomainId, ns~ : Int64) -> Instant[D]

#
Instant::ns

fn[D] Instant::ns(self : Instant[D]) -> Int64

#
SimTruth

pub(all) enum SimTruth {
SimTruth
} derive(Eq,
Debug
)

#
Uncertain

pub(all) struct Uncertain[T] {
value : T
bound :
Duration

}

#
VirtualClock

pub struct VirtualClock[D] {
// private fields
}

#
VirtualClock::advance

#
VirtualClock::domain

fn[D] VirtualClock::domain(self : VirtualClock[D]) -> DomainId

#
VirtualClock::new

fn[D] VirtualClock::new(domain~ : DomainId, seed~ : Int) -> VirtualClock[D]

#
VirtualClock::now

fn[D] VirtualClock::now(self : VirtualClock[D]) -> Instant[D]

#
VirtualClock::resolution

#
VirtualClock::seed

fn[D] VirtualClock::seed(self : VirtualClock[D]) -> Int

#
VirtualClock::set

fn[D] VirtualClock::set(self : VirtualClock[D], instant : Instant[D]) -> Unit

#
VirtualClock::sleep_until

fn[D] VirtualClock::sleep_until(self : VirtualClock[D], deadline : Instant[D]) -> Unit

#
VirtualClock::sleep_until_domain

fn[D] VirtualClock::sleep_until_domain(self : VirtualClock[D], deadline : DomainInstant) -> Unit

#
VirtualCrossStamper

pub struct VirtualCrossStamper[A, B] {
// private fields
}

#
VirtualCrossStamper::new

fn[A, B] VirtualCrossStamper::new(source~ : VirtualClock[A], relation~ : ClockRelation[A, B]) -> VirtualCrossStamper[A, B]

#
VirtualCrossStamper::typed_cross_stamp

fn[A, B] VirtualCrossStamper::typed_cross_stamp(self : VirtualCrossStamper[A, B]) -> CrossStamp[A, B]

#
WallDomain

pub(all) enum WallDomain {
WallDomain
} derive(Eq,
Debug
)

#
deterministic_sequence

fn[D] deterministic_sequence(domain~ : DomainId, seed~ : Int, count~ : Int, step~ :
Duration
) -> Array[Instant[D]]

#
ghost_domain_status

fn ghost_domain_status() -> String

#
package_id

fn package_id() -> String

Source Files