Enum Decision 

#[non_exhaustive]
pub enum Decision {
    Allowed,
    Denied {
        retry_after: Duration,
    },
}

The result of attempting to take tokens from a bucket.

Returned by Bucket::acquire. The acquire path is infallible — there is no error case, only an allow/deny outcome — so this is a plain enum rather than a Result. When the request is denied, the decision carries how long the caller should wait before enough tokens will have accrued, which is exactly what a downstream limiter (e.g. rate-net) needs to populate a Retry-After.

#[non_exhaustive] so future variants can be added without breaking callers; match with a wildcard arm, or use the is_allowed / retry_after helpers.

Examples

use better_bucket::{Bucket, Decision};

let bucket = Bucket::per_second(1);
match bucket.acquire(1) {
    Decision::Allowed => { /* serve the request */ }
    Decision::Denied { retry_after } => {
        // tell the caller when to come back
        let _ = retry_after;
    }
    _ => {}
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Allowed

The tokens were granted and have been deducted from the bucket.

Denied

The request was refused because the bucket did not hold enough tokens.

Fields

retry_after: Duration

The minimum wait until the bucket will hold enough tokens to grant the same request. Duration::MAX means the request can never succeed (it asked for more tokens than the bucket’s capacity).

Implementations

impl Decision

pub const fn is_allowed(&self) -> bool

Returns true if the request was granted.

Examples

use better_bucket::Decision;

assert!(Decision::Allowed.is_allowed());

pub const fn is_denied(&self) -> bool

Returns true if the request was refused.

Examples

use better_bucket::Decision;
use std::time::Duration;

let denied = Decision::Denied { retry_after: Duration::from_millis(250) };
assert!(denied.is_denied());

pub const fn retry_after(&self) -> Option<Duration>

Returns the wait until the request would succeed, or None if it was allowed.

Examples

use better_bucket::Decision;
use std::time::Duration;

let denied = Decision::Denied { retry_after: Duration::from_millis(250) };
assert_eq!(denied.retry_after(), Some(Duration::from_millis(250)));
assert_eq!(Decision::Allowed.retry_after(), None);

Trait Implementations

impl Clone for Decision

fn clone(&self) -> Decision

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Decision

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

Formats the value using the given formatter.

impl PartialEq for Decision

fn eq(&self, other: &Decision) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Decision

impl Eq for Decision

impl StructuralPartialEq for Decision