Struct htb::HTB

pub struct HTB<T> {
    pub unit_cost: usize,
    /* private fields */
}

Hierarchical Token Bucket structure

You can advance time for HTB structure using advance and advance_ns and examine/alter internal state using peek/take.

When several buckets are feeding from a single parent earlier one gets a priority

Fields

unit_cost: usize

Normalized unit cost

Implementations

impl<T> HTB<T> where
    T: Copy + Eq + PartialEq,
    usize: From<T>, 

pub fn new(tokens: &[BucketCfg<T>]) -> Result<Self, Error>

Create HTB for a given bucket configuration

Buckets should be given in depth first search traversal order:

• root with parent set to None
• higher priority child of the root
• followed by high priority child of the child, if any, etc.
• followed by the next child

pub fn advance_ns(&mut self, time_diff: usize)

Advance time by number of nanoseconds

Updates internal structure, see also advance

Performance

Update cost is O(N) where N is number of buckets

pub fn advance(&mut self, time_diff: Duration)

Advance time by Duration

Updates internal structure, see also advance_ns

pub fn peek(&self, label: T) -> bool

Check if there’s at least one token available at index T

See also peek_n

pub fn peek_n(&self, label: T, cnt: usize) -> bool

Check if there’s at least cnt tokens available at index T

See also peek

pub fn take(&mut self, label: T) -> bool

Consume a single token from T

See also take_n

pub fn take_n(&mut self, label: T, cnt: usize) -> bool

Consume cnt tokens from T

See also take

Trait Implementations

impl<T: Debug> Debug for HTB<T>

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

Formats the value using the given formatter.

impl<T> Index<T> for HTB<T> where
    usize: From<T>, 

type Output = usize

The returned type after indexing.

fn index(&self, index: T) -> &Self::Output

Performs the indexing (container[index]) operation.