Struct RateLimiterMap 

pub struct RateLimiterMap<K> { /* private fields */ }

A per-key rate limiter map.

Each key can be assigned its own rate and interval via insert_rate. Keys that have not been inserted are rejected by default — call insert_rate or insert_rate_interval first.

Example

use load_balancer::rate_limit::RateLimiterMap;
use std::time::Duration;

#[tokio::main]
async fn main() {
    let map = RateLimiterMap::new();

    // alice: 3 req/s,  bob: 10 req/s
    map.insert_rate("alice", 3);
    map.insert_rate_interval("bob", 10, Duration::from_secs(1));

    assert!(map.check(&"alice").await);
    assert!(map.check(&"bob").await);
    assert!(!map.check(&"charlie").await); // not inserted → rejected
}

Implementations

impl<K> RateLimiterMap<K>

where K: Hash + Eq + Clone + Send + Sync + 'static,

pub fn new() -> Self

Create an empty map.

pub fn insert_rate(&self, key: K, rate: u64)

Insert a rate limiter for key with the given rate and a 1-second interval.

Overwrites any existing limiter for the same key.

pub fn insert_rate_interval(&self, key: K, rate: u64, interval: Duration)

Insert a rate limiter for key with the given rate and interval.

pub fn remove(&self, key: &K)

Remove the rate limiter for key.

After removal the key is unknown and will be rejected by check (same as a key that was never inserted).

pub fn len(&self) -> usize

Returns the number of keys currently managed.

pub fn is_empty(&self) -> bool

Returns true if no keys are being rate-limited.

pub fn contains_key(&self, key: &K) -> bool

Returns true if key has an active rate limiter.

pub fn clear(&self)

Remove all rate limiters.

pub fn retain(&self, f: impl FnMut(&K, &mut RateLimiter) -> bool)

Retain only the keys for which f returns true.

Each remaining key’s limiter is unchanged.

pub fn entry(&self, key: K) -> Entry<'_, K, RateLimiter>

Get an Entry for key, allowing in-place insertion or modification.

Use entry(key).or_insert(limiter) to insert a limiter only if the key is absent, or entry(key).and_modify(...) to adjust an existing one.

pub async fn check(&self, key: &K) -> bool

Check whether key is allowed right now.

Returns true if the key’s limiter has available tokens. Returns false if the key has not been inserted (unknown keys are rejected by default).

pub async fn check_opt(&self, key: &K) -> Option<bool>

Check key and distinguish “unknown” from “rate-limited”.

Returns Some(true) if allowed, Some(false) if rate-limited, None if the key has not been inserted.

pub async fn time_until_available(&self, key: &K) -> Duration

Returns the duration until key becomes available again.

Returns Duration::MAX if the key is not inserted or the rate is zero, Duration::ZERO if tokens are immediately available.

pub async fn wait(&self, key: &K)

Block until key is allowed, then consume a token.

Returns immediately if the key is not inserted (no-op).

Trait Implementations

impl<K: Clone> Clone for RateLimiterMap<K>

fn clone(&self) -> RateLimiterMap<K>

Returns a duplicate of the value.

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

Performs copy-assignment from source.