Struct ArrayQueue

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

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, 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 push_mut(&mut self, value: T) -> Result<(), T>

Attempts to push an element using an exclusive reference of the queue.

Atomic operations and checks are omitted

Examples

use crossbeam_queue::ArrayQueue;

let mut q = ArrayQueue::new(1);

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

fn force_push(&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) -> 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 pop_mut(&mut self) -> Option<T>

Attempts to pop an element using an exclusive reference of the queue.

Due to having an exclusive reference, atomic operations and checks are omitted

Examples

use crossbeam_queue::ArrayQueue;

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

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

fn capacity(&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) -> 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) -> 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) -> 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);

Trait Implementations

impl<T> Debug for ArrayQueue<T>

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

impl<T> Drop for ArrayQueue<T>

fn drop(&mut self)

impl<T> IntoIterator for ArrayQueue<T>

type Item = T;
type IntoIter = IntoIter<T>;
fn into_iter(self) -> Self::IntoIter

impl<T> RefUnwindSafe for ArrayQueue<T>

impl<T> UnwindSafe for ArrayQueue<T>

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

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

Auto Trait Implementations

impl<T> !Freeze for ArrayQueue<T>

impl<T> Unpin for ArrayQueue<T> where Box<[Slot<T>]>: Unpin,

impl<T> UnsafeUnpin for ArrayQueue<T> where Box<[Slot<T>]>: UnsafeUnpin,

Blanket Implementations

impl<T> Any for ArrayQueue<T> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for ArrayQueue<T> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for ArrayQueue<T> where T: ?Sized,

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

impl<T> From<T> for ArrayQueue<T>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for ArrayQueue<T> where U: From<T>,

fn into(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<U> for ArrayQueue<T> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for ArrayQueue<T> where U: TryFrom<T>,

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