Struct AtomicManualClock 

pub struct AtomicManualClock<P = Timestamp> { /* private fields */ }

A clock set and moved by hand, shared across threads.

A thread that reads a point another set or moved the clock to also sees what that thread wrote before. It is not Clone, since a copy would fork time: share it by reference or Arc.

Examples

use std::thread;

use t2t_clock::{AtomicManualClock, Clock};
use t2t_core::{Timedelta, Uptime};

let clock = AtomicManualClock::new(Uptime::from_secs(1));
thread::scope(|scope| {
    scope.spawn(|| clock.advance(Timedelta::SECOND));
});
assert_eq!(clock.now(), Uptime::from_secs(2), "the other thread's move");

Implementations

impl<P: TimePoint> AtomicManualClock<P>

pub fn new(start: P) -> Self

A clock reading start.

pub fn set(&self, point: P)

Moves the clock to point, earlier or later.

pub fn advance(&self, span: P::Span)

Moves the clock by span, back for a negative one, saturating as the point’s addition does.

Trait Implementations

impl<P: TimePoint> Clock for AtomicManualClock<P>

type Reading = P

What the clock reads.

fn now(&self) -> P

The time now.

impl<P> Debug for AtomicManualClock<P>

where P: TimePoint + Debug,

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

Formats the value using the given formatter.

impl<P: TimePoint + Default> Default for AtomicManualClock<P>

By hand, since a derived one would start the count at zero, not at the point’s default.

fn default() -> Self

Returns the “default value” for a type.