Struct ClaimTime 

pub struct ClaimTime { /* private fields */ }

What: One reading of the three clocks. Why: A claim carries the reading taken when it was last renewed; whoever judges the claim takes a reading of its own.

In TS you’d write (pseudocode):

type ClaimTime = { bootId: string; monotonicMillis: number; wallSeconds: number };

Implementations

impl ClaimTime

Methods over a reading.

pub fn read() -> ClaimTime

A reading of the clocks now.

pub fn from_parts( boot_id: &str, monotonic: Duration, wall: Duration, ) -> ClaimTime

A reading of the given parts on a machine with no ID, which is how a test says what the clocks showed.

pub fn advanced(&self, by: Duration) -> ClaimTime

The reading by later on both clocks, which is time passing.

pub fn rewound(&self, by: Duration) -> ClaimTime

The reading by earlier on both clocks, which is how a test makes a claim whose holder last renewed that long ago.

pub fn wall_stepped_forward(&self, by: Duration) -> ClaimTime

The reading with the wall clock set by forward and the monotonic clock untouched, which is a clock step.

pub fn wall_stepped_back(&self, by: Duration) -> ClaimTime

The reading with the wall clock set by back and the monotonic clock untouched, which is a clock step.

pub fn in_boot(&self, boot_id: &str) -> ClaimTime

The reading in another boot, which is a restart of the host.

pub fn on_machine(&self, machine_id: &str) -> ClaimTime

The reading on the machine with the given ID, which is how a test puts two readings on one machine or on two.

pub fn from_wall(wall: SystemTime) -> ClaimTime

The reading a wall-clock time stands for where there is nothing else, such as the modification time of a claim an earlier release stamped.

pub fn elapsed_since(&self, earlier: &ClaimTime) -> Duration

How long ago earlier was, by the clock the two readings share: the monotonic clock within one boot, the wall clock where either has no boot ID. A reading from the future of this one counts as no time at all. Readings of two different boots share no clock that says how long the earlier holder lived, so a judge asks is_past_the_boot_of first.

pub fn is_past_the_boot_of(&self, earlier: &ClaimTime) -> bool

What: Whether earlier was read in a boot this reading is not in, on the same machine, so whoever took it is gone. Why: A restart ends every process of the host, so the holder of an earlier boot’s claim is dead and waiting out its lease on the wall clock only strands the claim when the clock was set back at boot. A different boot ID of another machine says nothing about the holder, which may be running there, so the answer is yes only when both machine IDs are known and equal. Without a boot ID or a machine ID on either side there is nothing to compare, and the answer is no: the lease decides.

In TS you’d write (pseudocode):

now.machineId !== '' && now.machineId === then.machineId
  && now.bootId !== '' && then.bootId !== '' && now.bootId !== then.bootId

pub fn encode(&self) -> String

The reading as the file-name parts boot~monotonic~wall~machine; a reading with no machine ID leaves the last part out, which is the form every release before machine IDs wrote and reads.

pub fn decode(text: &str) -> Option<ClaimTime>

The reading encode wrote, or nothing for any other text. The form without a machine ID, which releases before machine IDs wrote into claims that may still be on disk, reads as a reading with none.

Trait Implementations

impl Clone for ClaimTime

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ClaimTime

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for ClaimTime

impl PartialEq for ClaimTime

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ClaimTime