Struct squeue::SyncQueue

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

Thread-safe FIFO queue with a fixed capacity.

Similar to the standard non thread-safe version, but can be used for queueing in multiple consumers/producers contexts. There’s no subscription though, one needs to do some polling.

The peek function needs items to support Clone.

Examples

use squeue::SyncQueue;

// Does not need to be `mut`
let mut queue: SyncQueue<usize> = SyncQueue::new(3);
assert_eq!(None, queue.push(1));
assert_eq!(None, queue.push(2));
assert_eq!(None, queue.push(3));
assert_eq!(Some(1), queue.push(4));
assert_eq!(3, queue.len());

Implementations

impl<T> SyncQueue<T>

pub fn new(capacity: usize) -> Self

Create a new queue.

Examples

use squeue::SyncQueue;

let queue: SyncQueue<String> = SyncQueue::new(10);
assert_eq!(10, queue.capacity());

pub fn len(&self) -> usize

Return queue length.

Examples

use squeue::SyncQueue;

let queue: SyncQueue<&str> = SyncQueue::new(10);
assert_eq!(0, queue.len());
queue.push("x");
queue.push("y");
assert_eq!(2, queue.len());

pub fn capacity(&self) -> usize

Return queue capacity.

Examples

use squeue::SyncQueue;

let queue: SyncQueue<f64> = SyncQueue::new(100);
assert_eq!(100, queue.capacity());

pub fn is_empty(&self) -> bool

Returns true if queue is empty.

Examples

use squeue::SyncQueue;

let queue: SyncQueue<String> = SyncQueue::new(100);
assert!(queue.is_empty());
queue.push(String::from("abc"));
assert!(!queue.is_empty());

pub fn is_full(&self) -> bool

Returns true if queue is full.

Examples

use squeue::SyncQueue;

let queue: SyncQueue<usize> = SyncQueue::new(10);
assert!(!queue.is_full());
for i in 0..10 {
    queue.push(i);
}
assert!(queue.is_full());

pub fn clear(&self)

Clear all data.

Examples

use squeue::SyncQueue;

let queue: SyncQueue<String> = SyncQueue::new(100);
queue.push(String::from("abc"));
queue.clear();
assert!(queue.is_empty());

pub fn resize(&self, capacity: usize) -> usize

Resize queue.

Returns the number of dropped items, if any.

Examples

use squeue::SyncQueue;

let queue: SyncQueue<usize> = SyncQueue::new(10);
assert_eq!(10, queue.capacity());
assert_eq!(0, queue.resize(100));
assert_eq!(100, queue.capacity());
for i in 0..1000 {
    queue.push(i);
}
assert_eq!(100, queue.len());
assert_eq!(90, queue.resize(10));
assert_eq!(10, queue.capacity());
assert_eq!(10, queue.len());
assert_eq!(Some(990), queue.pop());

pub fn push(&self, item: T) -> Option<T>

Push data into the queue.

If the queue is full and data needs to be dropped, that data is returned.

Examples

use squeue::SyncQueue;

let queue: SyncQueue<usize> = SyncQueue::new(2);
assert_eq!(None, queue.push(1));
assert_eq!(None, queue.push(10));
assert_eq!(Some(1), queue.push(100));
assert_eq!(Some(10), queue.push(1000));
assert_eq!(2, queue.len());

pub fn pop(&self) -> Option<T>

Pop data from the queue.

The oldest item is returned, this works in FIFO mode.

Examples

use squeue::SyncQueue;

let queue: SyncQueue<usize> = SyncQueue::new(5);
assert_eq!(None, queue.pop());
assert_eq!(None, queue.push(1));
assert_eq!(Some(1), queue.pop());
assert_eq!(None, queue.push(2));
assert_eq!(None, queue.push(3));
assert_eq!(Some(2), queue.pop());
assert_eq!(1, queue.len());

pub fn drain(&mut self) -> Drain<T>

Creates an iterator which drains the queue.

Use this when you want to get all the items, at a given point, and free space in the queue.

use squeue::SyncQueue;

let mut queue = SyncQueue::new(10);
queue.push(1);
queue.push(10);
let drain = queue.drain();
assert_eq!(0, queue.len());
assert_eq!(2, drain.count());

impl<T> SyncQueue<T>where
T: Clone,

pub fn peek(&self) -> Option<T>

Peek data, get it without removing it.

This gives an insight on what pop() would return. Items need to support Clone.

Examples

use squeue::SyncQueue;

let queue: SyncQueue<usize> = SyncQueue::new(5);
assert_eq!(None, queue.peek());
assert_eq!(None, queue.push(1));
assert_eq!(None, queue.push(2));
assert_eq!(Some(1), queue.peek());

Trait Implementations

impl<T: Clone> Clone for SyncQueue<T>

fn clone(&self) -> SyncQueue<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for SyncQueue<T>

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

Formats the value using the given formatter.

impl<'de, V> Deserialize<'de> for SyncQueue<V>where
V: 'de + Deserialize<'de> + Clone,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
D: Deserializer<'de>,

Deserialize the queue.

Queue and SyncQueue share the same representation so it is fine to (de)serialize from any of them.

use squeue::SyncQueue;

let export = "{\"capacity\":7,\"data\":[1,4,3]}";

let queue: SyncQueue<usize> = serde_json::from_str(&export).unwrap();

assert_eq!(3, queue.len());
assert_eq!(7, queue.capacity());
assert_eq!(Some(3), queue.pop());
assert_eq!(Some(4), queue.pop());
assert_eq!(Some(1), queue.pop());
assert_eq!(None, queue.pop());

impl<T> Display for SyncQueue<T>where
T: Display,

Pretty-print queue content.

Prints the next element to be popped, and the len/capacity.

Examples

use squeue::SyncQueue;

let queue = SyncQueue::new(100);
queue.push(123);
queue.push(4);
queue.push(5);
assert_eq!("[sync] { next: 123, len: 3, capacity: 100 }", format!("{}", queue));
queue.clear();
assert_eq!("[sync] { len: 0, capacity: 100 }", format!("{}", queue));

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

Formats the value using the given formatter.

impl<T> From<Queue<T>> for SyncQueue<T>

Create a thread-safe queue from an ordinary queue.

Examples

use squeue::{Queue, SyncQueue};

let a: Queue<String> = Queue::new(100);
let b = SyncQueue::from(a);
assert_eq!(100, b.capacity());

fn from(queue: Queue<T>) -> SyncQueue<T>

Converts to this type from the input type.

impl<T> From<SyncQueue<T>> for Queue<T>where
T: Clone,

Create an ordinary queue from a thread-safe queue.

This is possibly slow as it is O(n) since it clones the queue.

Examples

use squeue::{Queue, SyncQueue};

let a: SyncQueue<String> = SyncQueue::new(100);
let b = Queue::from(a);
assert_eq!(100, b.capacity());

fn from(queue: SyncQueue<T>) -> Queue<T>

Converts to this type from the input type.

impl<T> FromIterator<T> for SyncQueue<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a new queue from an iterator.

With this, you can use collect() to build a queue.

Examples

use squeue::SyncQueue;

let src: Vec<usize> = vec![4, 5, 6];

let queue = src.into_iter().collect::<SyncQueue<usize>>();
assert_eq!(Some(4), queue.pop());
assert_eq!(Some(5), queue.pop());
assert_eq!(Some(6), queue.pop());
assert_eq!(None, queue.pop());
assert_eq!(3, queue.capacity());

impl<V> Serialize for SyncQueue<V>where
V: Serialize + Clone,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where
S: Serializer,

Serialize the sync queue.

This is possibly long, and requires data to support Clone. Internally, extracts non-sync version and serializes it.

use squeue::SyncQueue;
use serde_json::json;

let queue = SyncQueue::new(10);

queue.push(7);
queue.push(22);

let export = json!(&queue).to_string();

assert_eq!("{\"capacity\":10,\"data\":[22,7]}", export);