Struct Hybrid 

pub struct Hybrid { /* private fields */ }

Available on crate feature std only.

Several limiters combined so a request must satisfy all of them.

The classic use is layering windows on one resource — say “at most 10 per second and at most 100 per minute” — where either ceiling can bind. A hybrid is itself a Limiter, so hybrids nest and slot anywhere a single limiter does.

Acquisition is two-phase to stay correct: every constituent is first peeked, and tokens are only taken once all of them would grant. Without that, an early constituent could spend a token for a request a later one refuses. See Limiter for the full rationale.

Build one with Hybrid::builder.

Examples

use std::time::Duration;
use throttle_net::{Hybrid, Throttle};

// 10 per second, and no more than 100 per minute.
let hybrid = Hybrid::builder()
    .limiter(Throttle::per_second(10))
    .limiter(Throttle::per_duration(100, Duration::from_secs(60)))
    .build();

assert!(hybrid.try_acquire());

Implementations

impl Hybrid

pub fn builder() -> HybridBuilder

Starts building a hybrid limiter.

pub fn try_acquire(&self) -> bool

Attempts to take one token from every constituent without waiting, returning whether all granted.

All-or-nothing across constituents: either every one is debited or, on a refusal, the call reports failure.

Examples

use throttle_net::{Hybrid, Throttle};

let hybrid = Hybrid::builder().limiter(Throttle::per_second(1)).build();
assert!(hybrid.try_acquire());
assert!(!hybrid.try_acquire());

pub fn try_acquire_with_cost(&self, cost: u32) -> bool

Attempts to take cost tokens from every constituent without waiting.

impl Hybrid

pub async fn acquire(&self) -> Result<(), ThrottleError>

Available on crate feature runtime only.

Takes one token from every constituent, waiting until all are free.

Errors

Returns ThrottleError::CostExceedsCapacity if some constituent’s capacity is too small to ever grant the request.

Examples

use throttle_net::{Hybrid, Throttle};

let hybrid = Hybrid::builder().limiter(Throttle::per_second(100)).build();
hybrid.acquire().await?;

pub async fn acquire_with_cost(&self, cost: u32) -> Result<(), ThrottleError>

Available on crate feature runtime only.

Takes cost tokens from every constituent, waiting until all are free.

Errors

Returns ThrottleError::CostExceedsCapacity if some constituent can never grant cost.

Trait Implementations

impl Clone for Hybrid

fn clone(&self) -> Hybrid

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Limiter for Hybrid

fn available(&self) -> u32

The headroom of the binding constituent: the fewest tokens any one of them has available. An empty hybrid is unbounded (u32::MAX).

fn capacity(&self) -> u32

The capacity of the binding constituent: the smallest capacity among them, since that is the first ceiling a request hits. An empty hybrid is unbounded (u32::MAX).

fn peek(&self, cost: u32) -> Decision

Reports whether cost tokens would be granted now, without taking them.

fn acquire_cost(&self, cost: u32) -> Decision

Attempts to take cost tokens now, deducting them on success.