Struct StdTimeSource 

pub struct StdTimeSource { /* private fields */ }

Standard library time source using std::time::Instant.

StdTimeSource provides real-time operation using std::time::Instant. It maintains an internal starting point and returns the elapsed time since that point, following the TimeSource “elapsed time” model.

Characteristics

• Monotonic: Time never goes backward
• High Precision: Nanosecond precision from std::time
• Real Time: Uses actual system time
• Thread Safe: Safe to use across multiple threads

Time Model

The time source captures a starting Instant when created and returns the elapsed Duration since that point. This ensures:

• Consistent zero point across the lifetime of the time source
• Monotonic progression even across system clock adjustments
• Predictable behavior for rate limiting calculations

Examples

Creating and Using

use rate_guard::time_source::{TimeSource, StdTimeSource};
use std::time::Duration;

let time_source = StdTimeSource::new();
 
// Initially close to zero
let start = time_source.now();
assert!(start < Duration::from_millis(1));

// Time progresses naturally
std::thread::sleep(Duration::from_millis(50));
let later = time_source.now();
assert!(later >= Duration::from_millis(45)); // Allow tolerance

Precision Demonstration

use rate_guard::time_source::{TimeSource, StdTimeSource};
use rate_guard::precision::{Precision, Nanos, Millis};

let time_source = StdTimeSource::new();
std::thread::sleep(std::time::Duration::from_millis(10));
 
let elapsed = time_source.now();
let nanos = Nanos::to_ticks(elapsed);
let millis = Millis::to_ticks(elapsed);
 
println!("Elapsed: {} ns, {} ms", nanos, millis);

Implementations

impl StdTimeSource

pub fn new() -> Self

Creates a new StdTimeSource with the current instant as the starting point.

The starting point is captured immediately and used as the reference for all subsequent time measurements.

Examples

use rate_guard::time_source::StdTimeSource;

let time_source = StdTimeSource::new();
// time_source.now() will return elapsed time from this moment

pub fn elapsed(&self) -> Duration

Returns the elapsed Duration since this time source was created.

This is equivalent to calling the now() method from the TimeSource trait, but provided as a convenience method with a more descriptive name.

Examples

use rate_guard::time_source::{TimeSource, StdTimeSource};
use std::time::Duration;

let time_source = StdTimeSource::new();
std::thread::sleep(Duration::from_millis(10));
 
let elapsed = time_source.elapsed();
assert!(elapsed >= Duration::from_millis(9)); // Allow tolerance
 
// elapsed() and now() should return very similar values
let now_time = time_source.now();
let elapsed_time = time_source.elapsed();
 
// They should be within a small tolerance (microseconds)
let diff = if now_time > elapsed_time {
    now_time - elapsed_time
} else {
    elapsed_time - now_time
};
assert!(diff < Duration::from_micros(100)); // Should be very close

pub fn start_instant(&self) -> Instant

Returns the starting instant for this time source.

This method provides access to the internal starting point, which can be useful for debugging or advanced time calculations.

Examples

use rate_guard::time_source::StdTimeSource;
use std::time::Instant;

let time_source = StdTimeSource::new();
let start_instant = time_source.start_instant();
 
// The start instant should be very recent
assert!(start_instant.elapsed().as_millis() < 100);

Trait Implementations

impl Clone for StdTimeSource

fn clone(&self) -> StdTimeSource

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StdTimeSource

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

Formats the value using the given formatter.

impl Default for StdTimeSource

fn default() -> Self

Creates a new StdTimeSource with default settings.

Equivalent to StdTimeSource::new().

impl TimeSource for StdTimeSource

fn now(&self) -> Duration

Returns the elapsed Duration since this StdTimeSource was created.

This method returns the time elapsed since the starting instant captured during construction. The returned Duration is guaranteed to be monotonic and will never decrease between calls.

Performance

This method is marked #[inline(always)] to ensure optimal performance in high-frequency rate limiting scenarios.

Examples

use rate_guard::time_source::{TimeSource, StdTimeSource};
use std::time::Duration;

let time_source = StdTimeSource::new();

let t1 = time_source.now();
std::thread::sleep(Duration::from_millis(10));
let t2 = time_source.now();

// Monotonic guarantee
assert!(t2 >= t1);
assert!(t2 - t1 >= Duration::from_millis(8)); // Allow tolerance