Struct multiqueue::MPMCReceiver[−][src]

pub struct MPMCReceiver<T> { /* fields omitted */ }

Expand description

This is the receiving end of a standard mpmc view of the queue It functions similarly to the BroadcastReceiver execpt there is only ever one stream. As a result, the type doesn’t need to be clone

Implementations

[src]

impl<T> MPMCReceiver<T>

[src]

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

Tries to receive a value from the queue without blocking.

Examples:

use multiqueue::mpmc_queue;
let (w, r) = mpmc_queue(10);
w.try_send(1).unwrap();
assert_eq!(1, r.try_recv().unwrap());

use multiqueue::mpmc_queue;
use std::thread;

let (send, recv) = mpmc_queue(10);

let handle = thread::spawn(move || {
    for _ in 0..10 {
        loop {
            match recv.try_recv() {
                Ok(val) => {
                    println!("Got {}", val);
                    break;
                },
                Err(_) => (),
            }
        }
    }
    assert!(recv.try_recv().is_err()); // recv would block here
});

for i in 0..10 {
    send.try_send(i).unwrap();
}

// Drop the sender to close the queue
drop(send);

handle.join();

[src]

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

Receives a value from the queue, blocks until there is data.

Examples:

use multiqueue::mpmc_queue;
let (w, r) = mpmc_queue(10);
w.try_send(1).unwrap();
assert_eq!(1, r.recv().unwrap());

use multiqueue::mpmc_queue;
use std::thread;

let (send, recv) = mpmc_queue(10);

let handle = thread::spawn(move || {
    // note the lack of dealing with failed reads.
    // unwrap 'ignores' the error where sender disconnects
    for _ in 0..10 {
        println!("Got {}", recv.recv().unwrap());
    }
    assert!(recv.try_recv().is_err());
});

for i in 0..10 {
    send.try_send(i).unwrap();
}

// Drop the sender to close the queue
drop(send);

handle.join();

[src]

pub fn unsubscribe(self) -> bool

Removes the given reader from the queue subscription lib Returns true if this is the last reader in a given broadcast unit

Examples

use multiqueue::mpmc_queue;
let (writer, reader) = mpmc_queue(2);
writer.try_send(1).expect("This will succeed since queue is empty");
reader.try_recv().expect("This reader can read");
reader.unsubscribe();
// Fails since there's no readers left
assert!(writer.try_send(1).is_err());

[src]

pub fn into_single(self) -> Result<MPMCUniReceiver<T>, MPMCReceiver<T>>

If there is only one MPMCReceiver on the stream, converts the Receiver into a MPMCUniReceiver otherwise returns the MPMCReceiver.

Example:

use multiqueue::mpmc_queue;

let (w, r) = mpmc_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);

[src]

pub fn try_iter<'a>(&'a self) -> MPMCRefIter<'a, 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::mpmc_queue;
let (w, r) = mpmc_queue(2);
for _ in 0 .. 3 {
    w.try_send(1).unwrap();
    w.try_send(2).unwrap();
    for val in r.try_iter().zip(1..2) {
        assert_eq!(val.0, val.1);
    }
}