Struct ArrayQueue

struct ArrayQueue<T> { ... }

A bounded multi-producer multi-consumer queue.

This queue allocates a fixed-capacity buffer on construction, which is used to store pushed elements. The queue cannot hold more elements than the buffer allows. Attempting to push an element into a full queue will fail. Alternatively, force_push makes it possible for this queue to be used as a ring-buffer. Having a buffer allocated upfront makes this queue a bit faster than SegQueue.

Examples

use crossbeam_queue::ArrayQueue;

let q = ArrayQueue::new(2);

assert_eq!(q.push('a'), Ok(()));
assert_eq!(q.push('b'), Ok(()));
assert_eq!(q.push('c'), Err('c'));
assert_eq!(q.pop(), Some('a'));

Implementations

impl<T> ArrayQueue<T>

fn new(cap: usize) -> ArrayQueue<T>

Creates a new bounded queue with the given capacity.

Panics

Panics if the capacity is zero.

Examples

use crossbeam_queue::ArrayQueue;

let q = ArrayQueue::<i32>::new(100);

fn push(self: &Self, value: T) -> Result<(), T>

Attempts to push an element into the queue.

If the queue is full, the element is returned back as an error.

Examples

use crossbeam_queue::ArrayQueue;

let q = ArrayQueue::new(1);

assert_eq!(q.push(10), Ok(()));
assert_eq!(q.push(20), Err(20));

fn force_push(self: &Self, value: T) -> Option<T>

Pushes an element into the queue, replacing the oldest element if necessary.

If the queue is full, the oldest element is replaced and returned, otherwise None is returned.

Examples

use crossbeam_queue::ArrayQueue;

let q = ArrayQueue::new(2);

assert_eq!(q.force_push(10), None);
assert_eq!(q.force_push(20), None);
assert_eq!(q.force_push(30), Some(10));
assert_eq!(q.pop(), Some(20));

fn pop(self: &Self) -> Option<T>

Attempts to pop an element from the queue.

If the queue is empty, None is returned.

Examples

use crossbeam_queue::ArrayQueue;

let q = ArrayQueue::new(1);
assert_eq!(q.push(10), Ok(()));

assert_eq!(q.pop(), Some(10));
assert!(q.pop().is_none());

fn capacity(self: &Self) -> usize

Returns the capacity of the queue.

Examples

use crossbeam_queue::ArrayQueue;

let q = ArrayQueue::<i32>::new(100);

assert_eq!(q.capacity(), 100);

fn is_empty(self: &Self) -> bool

Returns true if the queue is empty.

Examples

use crossbeam_queue::ArrayQueue;

let q = ArrayQueue::new(100);

assert!(q.is_empty());
q.push(1).unwrap();
assert!(!q.is_empty());

fn is_full(self: &Self) -> bool

Returns true if the queue is full.

Examples

use crossbeam_queue::ArrayQueue;

let q = ArrayQueue::new(1);

assert!(!q.is_full());
q.push(1).unwrap();
assert!(q.is_full());

fn len(self: &Self) -> usize

Returns the number of elements in the queue.

Examples

use crossbeam_queue::ArrayQueue;

let q = ArrayQueue::new(100);
assert_eq!(q.len(), 0);

q.push(10).unwrap();
assert_eq!(q.len(), 1);

q.push(20).unwrap();
assert_eq!(q.len(), 2);

impl<T> Any for ArrayQueue<T>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for ArrayQueue<T>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for ArrayQueue<T>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> Debug for ArrayQueue<T>

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

impl<T> Drop for ArrayQueue<T>

fn drop(self: &mut Self)

impl<T> Freeze for ArrayQueue<T>

impl<T> From for ArrayQueue<T>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> IntoIterator for ArrayQueue<T>

fn into_iter(self: Self) -> <Self as >::IntoIter

impl<T> RefUnwindSafe for ArrayQueue<T>

impl<T> Unpin for ArrayQueue<T>

impl<T> UnsafeUnpin for ArrayQueue<T>

impl<T> UnwindSafe for ArrayQueue<T>

impl<T, U> Into for ArrayQueue<T>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for ArrayQueue<T>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for ArrayQueue<T>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T: Send> Send for ArrayQueue<T>

impl<T: Send> Sync for ArrayQueue<T>