Struct concurrent_queue::ConcurrentQueue [−][src]
A concurrent queue.
Examples
use concurrent_queue::{ConcurrentQueue, PopError, PushError}; let q = ConcurrentQueue::bounded(2); assert_eq!(q.push('a'), Ok(())); assert_eq!(q.push('b'), Ok(())); assert_eq!(q.push('c'), Err(PushError::Full('c'))); assert_eq!(q.pop(), Ok('a')); assert_eq!(q.pop(), Ok('b')); assert_eq!(q.pop(), Err(PopError::Empty));
Implementations
impl<T> ConcurrentQueue<T>
[src]
pub fn bounded(cap: usize) -> ConcurrentQueue<T>
[src]
Creates a new bounded queue.
The queue allocates enough space for cap
items.
Panics
If the capacity is zero, this constructor will panic.
Examples
use concurrent_queue::ConcurrentQueue; let q = ConcurrentQueue::<i32>::bounded(100);
pub fn unbounded() -> ConcurrentQueue<T>
[src]
Creates a new unbounded queue.
Examples
use concurrent_queue::ConcurrentQueue; let q = ConcurrentQueue::<i32>::unbounded();
pub fn push(&self, value: T) -> Result<(), PushError<T>>
[src]
Attempts to push an item into the queue.
If the queue is full or closed, the item is returned back as an error.
Examples
use concurrent_queue::{ConcurrentQueue, PushError}; let q = ConcurrentQueue::bounded(1); // Push succeeds because there is space in the queue. assert_eq!(q.push(10), Ok(())); // Push errors because the queue is now full. assert_eq!(q.push(20), Err(PushError::Full(20))); // Close the queue, which will prevent further pushes. q.close(); // Pushing now errors indicating the queue is closed. assert_eq!(q.push(20), Err(PushError::Closed(20))); // Pop the single item in the queue. assert_eq!(q.pop(), Ok(10)); // Even though there is space, no more items can be pushed. assert_eq!(q.push(20), Err(PushError::Closed(20)));
pub fn pop(&self) -> Result<T, PopError>
[src]
Attempts to pop an item from the queue.
If the queue is empty, an error is returned.
Examples
use concurrent_queue::{ConcurrentQueue, PopError}; let q = ConcurrentQueue::bounded(1); // Pop errors when the queue is empty. assert_eq!(q.pop(), Err(PopError::Empty)); // Push one item and close the queue. assert_eq!(q.push(10), Ok(())); q.close(); // Remaining items can be popped. assert_eq!(q.pop(), Ok(10)); // Again, pop errors when the queue is empty, // but now also indicates that the queue is closed. assert_eq!(q.pop(), Err(PopError::Closed));
pub fn is_empty(&self) -> bool
[src]
Returns true
if the queue is empty.
Examples
use concurrent_queue::ConcurrentQueue; let q = ConcurrentQueue::<i32>::unbounded(); assert!(q.is_empty()); q.push(1).unwrap(); assert!(!q.is_empty());
pub fn is_full(&self) -> bool
[src]
Returns true
if the queue is full.
An unbounded queue is never full.
Examples
use concurrent_queue::ConcurrentQueue; let q = ConcurrentQueue::bounded(1); assert!(!q.is_full()); q.push(1).unwrap(); assert!(q.is_full());
pub fn len(&self) -> usize
[src]
Returns the number of items in the queue.
Examples
use concurrent_queue::ConcurrentQueue; let q = ConcurrentQueue::unbounded(); assert_eq!(q.len(), 0); assert_eq!(q.push(10), Ok(())); assert_eq!(q.len(), 1); assert_eq!(q.push(20), Ok(())); assert_eq!(q.len(), 2);
pub fn capacity(&self) -> Option<usize>
[src]
Returns the capacity of the queue.
Unbounded queues have infinite capacity, represented as None
.
Examples
use concurrent_queue::ConcurrentQueue; let q = ConcurrentQueue::<i32>::bounded(7); assert_eq!(q.capacity(), Some(7)); let q = ConcurrentQueue::<i32>::unbounded(); assert_eq!(q.capacity(), None);
pub fn close(&self) -> bool
[src]
Closes the queue.
Returns true
if this call closed the queue, or false
if it was already closed.
When a queue is closed, no more items can be pushed but the remaining items can still be popped.
Examples
use concurrent_queue::{ConcurrentQueue, PopError, PushError}; let q = ConcurrentQueue::unbounded(); assert_eq!(q.push(10), Ok(())); assert!(q.close()); // `true` because this call closes the queue. assert!(!q.close()); // `false` because the queue is already closed. // Cannot push any more items when closed. assert_eq!(q.push(20), Err(PushError::Closed(20))); // Remaining items can still be popped. assert_eq!(q.pop(), Ok(10)); // When no more items are present, the error is `Closed`. assert_eq!(q.pop(), Err(PopError::Closed));
pub fn is_closed(&self) -> bool
[src]
Returns true
if the queue is closed.
Examples
use concurrent_queue::ConcurrentQueue; let q = ConcurrentQueue::<i32>::unbounded(); assert!(!q.is_closed()); q.close(); assert!(q.is_closed());
Trait Implementations
impl<T> Debug for ConcurrentQueue<T>
[src]
impl<T> RefUnwindSafe for ConcurrentQueue<T>
[src]
impl<T: Send> Send for ConcurrentQueue<T>
[src]
impl<T: Send> Sync for ConcurrentQueue<T>
[src]
impl<T> UnwindSafe for ConcurrentQueue<T>
[src]
Auto Trait Implementations
impl<T> Unpin for ConcurrentQueue<T> where
T: Unpin,
T: Unpin,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,