Struct TokioTimeSource 

pub struct TokioTimeSource { /* private fields */ }

Tokio time source using tokio::time::Instant.

TokioTimeSource provides time operations that are compatible with Tokio’s async runtime. It maintains an internal starting point and returns the elapsed time since that point, following the TimeSource “elapsed time” model.

Characteristics

• Tokio Compatible: Uses tokio::time::Instant for async runtime compatibility
• Monotonic: Time never goes backward
• High Precision: Nanosecond precision from tokio::time
• Runtime Aware: Respects Tokio’s time pausing in tests
• Thread Safe: Safe to use across multiple async tasks

Examples

use rate_guard::time_source::{TimeSource, TokioTimeSource};
use rate_guard::{Nanos, RateLimit};
use rate_guard::limits::TokenBucketBuilder;
use std::time::Duration;

#[tokio::main]
async fn main() {
    let bucket = TokenBucketBuilder::builder()
        .capacity(100)
        .refill_amount(10)
        .refill_every(Duration::from_millis(100))
        .with_time(TokioTimeSource::new())
        .with_precision::<Nanos>()
        .build()
        .unwrap();

    // Use with Tokio async runtime
    match bucket.try_acquire(10) {
        Ok(()) => println!("Request allowed"),
        Err(e) => println!("Rate limited: {}", e),
    }
}

Implementations

impl TokioTimeSource

pub fn new() -> Self

Creates a new TokioTimeSource 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::TokioTimeSource;

let time_source = TokioTimeSource::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, TokioTimeSource};
use std::time::Duration;

#[tokio::main]
async fn main() {
    let time_source = TokioTimeSource::new();
    tokio::time::sleep(Duration::from_millis(10)).await;
     
    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
    let diff = if now_time > elapsed_time {
        now_time - elapsed_time
    } else {
        elapsed_time - now_time
    };
    assert!(diff < Duration::from_micros(100));
}

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::TokioTimeSource;
use tokio::time::Instant;

#[tokio::main]
async fn main() {
    let time_source = TokioTimeSource::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 TokioTimeSource

fn clone(&self) -> TokioTimeSource

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TokioTimeSource

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

Formats the value using the given formatter.

impl Default for TokioTimeSource

Available on crate feature tokio-time only.

fn default() -> Self

Creates a new TokioTimeSource with default settings.

Equivalent to TokioTimeSource::new().

impl TimeSource for TokioTimeSource

Available on crate feature tokio-time only.

fn now(&self) -> Duration

Returns the elapsed Duration since this TokioTimeSource 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, TokioTimeSource};
use std::time::Duration;

#[tokio::main]
async fn main() {
    let time_source = TokioTimeSource::new();

    let t1 = time_source.now();
    tokio::time::sleep(Duration::from_millis(10)).await;
    let t2 = time_source.now();

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