Struct rate_limit_queue::RateLimitQueue

pub struct RateLimitQueue<T> { /* private fields */ }

A rate limited queue.

Implementations

impl<T> RateLimitQueue<T>

pub fn new(quantum: usize, interval: Duration) -> RateLimitQueue<T>

Creates an empty queue.

Examples

use rate_limit_queue::RateLimitQueue;

let queue: RateLimitQueue<i32> = RateLimitQueue::new(100, Duration::from_secs(1));

pub fn with_capacity(
    cap: usize,
    quantum: usize,
    interval: Duration
) -> RateLimitQueue<T>

Creates an empty queue with space for at least n elements.

Examples

use rate_limit_queue::RateLimitQueue;

let queue: RateLimitQueue<u32> = RateLimitQueue::with_capacity(10, 100, Duration::from_secs(1));

pub fn capacity(&mut self) -> usize

Returns the number of elements the queue can hold without reallocating.

pub fn reserve_exact(&mut self, additional: usize)

Reserves the minimum capacity for exactly additional more elements.

Panics

Panics if the new capacity overflows usize.

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more elements.

Panics

Panics if the new capacity overflows usize.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the queue as much as possible.

pub fn truncate(&mut self, len: usize)

Shortens the queue, dropping excess elements from the back.

pub fn len(&self) -> usize

Returns the number of elements in the queue.

pub fn is_empty(&self) -> bool

Returns true if the queue is empty.

pub fn set_quantum(&mut self, quantum: usize)

Changes the quantum.

pub fn set_interval(&mut self, interval: Duration)

Changes the interval.

pub fn enqueue(&mut self, value: T)

Appends an element to the back of the queue.

Examples

use rate_limit_queue::RateLimitQueue;

let mut queue = RateLimitQueue::new(100, Duration::from_secs(1));
queue.enqueue(1);
queue.enqueue(2);

pub fn dequeue(&mut self) -> Option<T>

Removes the first element and returns it, or None if the queue is empty.

Sleeps if the limit has been reached.

Examples

use rate_limit_queue::RateLimitQueue;

let mut queue = RateLimitQueue::new(100, Duration::from_secs(1));
queue.enqueue(1);
queue.enqueue(2);

assert_eq!(queue.dequeue(), Some(1));
assert_eq!(queue.dequeue(), Some(2));

pub fn try_dequeue(&mut self) -> DequeueResult<T>

Tries to remove the first element and return it.

Examples

use rate_limit_queue::{RateLimitQueue, DequeueResult};

let mut queue = RateLimitQueue::new(2, Duration::from_secs(10));
queue.enqueue(1);
queue.enqueue(2);

assert_eq!(queue.try_dequeue(), DequeueResult::Data(1));
assert_eq!(queue.try_dequeue(), DequeueResult::Data(2));
assert_eq!(queue.try_dequeue(), DequeueResult::Empty);

queue.enqueue(3);
assert!(queue.try_dequeue().is_limit());

pub fn iter(&mut self) -> impl Iterator<Item = &T>

Returns a front-to-back iterator.

Examples

use rate_limit_queue::{RateLimitQueue, DequeueResult};

let mut queue = RateLimitQueue::new(2, Duration::from_secs(10));
queue.enqueue(1);
queue.enqueue(2);

let b: &[_] = &[&1, &2];
let c: Vec<&i32> = queue.iter().collect();
assert_eq!(&c[..], b);

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>

Returns a front-to-back iterator that returns mutable references.

Examples

use rate_limit_queue::{RateLimitQueue, DequeueResult};

let mut queue = RateLimitQueue::new(2, Duration::from_secs(10));
queue.enqueue(1);
queue.enqueue(2);

let b: &[_] = &[&mut 1, &mut 2];
let c: Vec<&mut i32> = queue.iter_mut().collect();
assert_eq!(&c[..], b);

Trait Implementations

impl<T> Extend<T> for RateLimitQueue<T>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.