Struct multiqueue::BroadcastUniReceiver

pub struct BroadcastUniReceiver<T: Clone + Sync> { /* fields omitted */ }

This class is similar to the receiver, except it ensures that there is only one consumer for the stream it owns. This means that one can safely view the data in-place with the recv_view method family and avoid the cost of copying it. If there's only one receiver on a stream, it can be converted into a BroadcastUniInnerRecv

Example:

use multiqueue::broadcast_queue;

let (w, r) = broadcast_queue(10);
w.try_send(1).unwrap();
let r2 = r.clone();
// Fails since there's two receivers on the stream
assert!(r2.into_single().is_err());
let single_r = r.into_single().unwrap();
let val = match single_r.try_recv_view(|x| 2 * *x) {
    Ok(val) => val,
    Err(_) => panic!("Queue should have an element"),
};
assert_eq!(2, val);

Methods

impl<T: Clone + Sync> BroadcastUniReceiver<T>

fn try_recv(&self) -> Result<T, TryRecvError>

Identical to BroadcastReceiver::try_recv

fn recv(&self) -> Result<T, RecvError>

Identical to BroadcastReceiver::recv

fn try_recv_view<R, F: FnOnce(&T) -> R>(
    &self,
    op: F
) -> Result<R, (F, TryRecvError)>

Applies the passed function to the value in the queue without copying it out If there is no data in the queue or the writers have disconnected, returns an Err((F, TryRecvError))

Example

use multiqueue::broadcast_queue;

let (w, r) = broadcast_queue(10);
let single_r = r.into_single().unwrap();
for i in 0..5 {
    w.try_send(i).unwrap();
}

for i in 0..5 {
    let val = match single_r.try_recv_view(|x| 1 + *x) {
        Ok(val) => val,
        Err(_) => panic!("Queue shouldn't be disconncted or empty"),
    };
    assert_eq!(i + 1, val);
}
assert!(single_r.try_recv_view(|x| *x).is_err());
drop(w);
assert!(single_r.try_recv_view(|x| *x).is_err());

fn recv_view<R, F: FnOnce(&T) -> R>(&self, op: F) -> Result<R, (F, RecvError)>

Applies the passed function to the value in the queue without copying it out If there is no data in the queue, blocks until an item is pushed into the queue or all writers disconnect

Example

use multiqueue::broadcast_queue;

let (w, r) = broadcast_queue(10);
let single_r = r.into_single().unwrap();
for i in 0..5 {
    w.try_send(i).unwrap();
}

for i in 0..5 {
    let val = match single_r.recv_view(|x| 1 + *x) {
        Ok(val) => val,
        Err(_) => panic!("Queue shouldn't be disconncted or empty"),
    };
    assert_eq!(i + 1, val);
}
drop(w);
assert!(single_r.recv_view(|x| *x).is_err());

fn unsubscribe(self)

Almost identical to BroadcastReceiver::unsubscribe, except it doesn't return a boolean of whether this was the last receiver on the stream because a receiver of this type must be the last one on the stream

fn into_multi(self) -> BroadcastReceiver<T>

Transforms the BroadcastUniReceiver into a BroadcastReceiver

Example

use multiqueue::broadcast_queue;

let (w, r) = broadcast_queue(10);
w.try_send(1).unwrap();
let single_r = r.into_single().unwrap();
let normal_r = single_r.into_multi();
normal_r.clone();

fn iter_with<R, F: FnMut(&T) -> R>(self, op: F) -> BroadcastUniIter<R, F, T>

Returns a non-owning iterator that iterates over the queue until it fails to receive an item, either through being empty or begin disconnected. This iterator will never block.

Examples:

use multiqueue::broadcast_queue;
let (w, r) = broadcast_queue(2);
let sr = r.into_single().unwrap();
w.try_send(1).unwrap();
w.try_send(2).unwrap();
w.unsubscribe();
for val in sr.iter_with(|x| 2 * *x).zip(1..2) {
    assert_eq!(val.0, val.1 * 2);
}

fn try_iter_with<'a, R, F: FnMut(&T) -> R>(
    &'a self,
    op: F
) -> BroadcastUniRefIter<'a, R, F, T>

Returns a non-owning iterator that iterates over the queue until it fails to receive an item, either through being empty or begin disconnected. This iterator will never block.

Examples:

use multiqueue::broadcast_queue;
let (w, r) = broadcast_queue(2);
let sr = r.into_single().unwrap();
for _ in 0 .. 3 {
    w.try_send(1).unwrap();
    w.try_send(2).unwrap();
    for val in sr.try_iter_with(|x| 2 * *x).zip(1..2) {
        assert_eq!(val.0, val.1*2);
    }
}

Trait Implementations

impl<T: Clone + Sync> IntoIterator for BroadcastUniReceiver<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = BroadcastSCIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> BroadcastSCIter<T>

Creates an iterator from a value.

impl<'a, T: Clone + Sync + 'a> IntoIterator for &'a BroadcastUniReceiver<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = BroadcastSCRefIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> BroadcastSCRefIter<'a, T>

Creates an iterator from a value.

impl<T: Send + Clone + Sync> Send for BroadcastUniReceiver<T>