Struct ClockHandle 

pub struct ClockHandle { /* private fields */ }

A handle to a clock for getting time and performing time-based operations.

This is the main interface for time operations. It’s cheap to clone and can be shared across tasks and threads. All clones share the same underlying clock, so they see consistent time.

Creating a Clock

use es_entity::clock::ClockHandle;

// Real-time clock for production
let clock = ClockHandle::realtime();

// Manual clock for testing - returns (handle, controller)
let (clock, ctrl) = ClockHandle::manual();

Basic Operations

use es_entity::clock::ClockHandle;
use std::time::Duration;

let clock = ClockHandle::realtime();

// Get current time
let now = clock.now();

// Sleep for a duration
clock.sleep(Duration::from_secs(1)).await;

// Timeout a future
match clock.timeout(Duration::from_secs(5), some_async_operation()).await {
    Ok(result) => println!("Completed: {:?}", result),
    Err(_) => println!("Timed out"),
}

Implementations

impl ClockHandle

pub fn realtime() -> Self

Create a real-time clock that uses the system clock and tokio timers.

pub fn manual() -> (Self, ClockController)

Create a manual clock starting at the current time.

Returns a tuple of (ClockHandle, ClockController). The handle provides the common time interface, while the controller provides operations for advancing time.

Example

use es_entity::clock::ClockHandle;

let (clock, ctrl) = ClockHandle::manual();

pub fn manual_at(start_at: DateTime<Utc>) -> (Self, ClockController)

Create a manual clock starting at a specific time.

Returns a tuple of (ClockHandle, ClockController). The handle provides the common time interface, while the controller provides operations for advancing time.

Example

use es_entity::clock::ClockHandle;
use chrono::Utc;

let (clock, ctrl) = ClockHandle::manual_at(Utc::now() - chrono::Duration::days(30));

pub fn now(&self) -> DateTime<Utc>

Get the current time.

This is a fast, synchronous operation regardless of clock type.

For real-time clocks, this returns Utc::now(). For manual clocks, this returns the current manual time.

pub fn sleep(&self, duration: Duration) -> ClockSleep

Sleep for the given duration.

For real-time clocks, this delegates to tokio::time::sleep. For manual clocks, this waits until time is advanced.

pub fn timeout<F>(&self, duration: Duration, future: F) -> ClockTimeout<F>

where F: Future,

Apply a timeout to a future.

Returns Ok(output) if the future completes before the timeout, or Err(Elapsed) if the timeout expires first.

pub fn is_manual(&self) -> bool

Check if this clock is manual (as opposed to realtime).

pub fn today(&self) -> NaiveDate

Get the current date (without time component).

This is equivalent to clock.now().date_naive().

pub fn manual_now(&self) -> Option<DateTime<Utc>>

Get the current manual time, if this is a manual clock.

Returns:

• None for realtime clocks
• Some(time) for manual clocks

This is useful for code that needs to cache time when running under manual clocks but use fresh time for realtime clocks.

Trait Implementations

impl Clone for ClockHandle

fn clone(&self) -> ClockHandle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClockHandle

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

Formats the value using the given formatter.