Struct Window 

pub struct Window<T>
where
    T: Send + Sync + Clone + 'static,
{ /* private fields */ }

Sliding-window load balancer: each entry has a per-interval allocation cap.

Counts reset every interval (default 1 second); entries with max_count == 0 are unlimited.

Implementations

impl<T> Window<T>

where T: Send + Sync + Clone + 'static,

pub fn new(entries: Vec<(u64, T)>) -> Self

Create a Window with a 1-second reset interval.

Each tuple is (max_count, value) — max_count == 0 means unlimited.

pub fn new_interval(entries: Vec<(u64, T)>, interval: Duration) -> Self

Create a Window with a custom reset interval.

pub async fn update<F, R, N>(&self, handler: F) -> Result<N>

where F: Fn(Arc<Inner<T>>) -> R, R: Future<Output = Result<N>>,

Run an async callback with access to the internal state.

pub async fn update_timer<F, R>( &self, handler: F, interval: Duration, ) -> Result<JoinHandle<()>>

where F: Fn(Arc<Inner<T>>) -> R + Send + Sync + 'static, R: Future<Output = Result<()>> + Send,

Spawn a background task that calls handler every interval.

The handler is called once immediately; if that initial call fails the error is returned and no background task is spawned. Returns a JoinHandle that can be aborted to stop the timer.

Trait Implementations

impl<T> Clone for Window<T>

where T: Send + Sync + Clone + 'static + Clone,

fn clone(&self) -> Window<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> FilteredLoadBalancer<T> for Window<T>

where T: Send + Sync + Clone + 'static,

async fn alloc_filter( &self, predicate: impl FnMut((usize, &T)) -> bool + Send, ) -> (usize, T)

Asynchronously allocate an entry that satisfies the given predicate.

fn try_alloc_filter( &self, predicate: impl FnMut((usize, &T)) -> bool, ) -> Option<(usize, T)>

Attempt to allocate an entry that satisfies the predicate without awaiting.

impl<T> LoadBalancer<T> for Window<T>

where T: Send + Sync + Clone + 'static,

fn alloc(&self) -> impl Future<Output = T> + Send

Asynchronously allocate a resource from the pool.

fn try_alloc(&self) -> Option<T>

Attempt to allocate a resource synchronously without awaiting.