Struct ergo_sync::ch::Receiver

pub struct Receiver<T>(_);

The receiving half of a channel.

Receivers can be cloned and shared among multiple threads.

Examples

use std::thread;
use std::time::Duration;
use crossbeam_channel::unbounded;

let (tx, rx) = unbounded();

thread::spawn(move || {
    tx.send("Hello world!").unwrap();
    thread::sleep(Duration::from_secs(2)); // Block for two seconds.
    tx.send("Delayed for 2 seconds").unwrap();
});

println!("{}", rx.recv().unwrap()); // Received immediately.
println!("Waiting...");
println!("{}", rx.recv().unwrap()); // Received after 2 seconds.

Methods

impl<T> Receiver<T>

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

Attempts to receive a message from the channel without blocking.

This method will never block in order to wait for a message to become available. Instead, this will always return immediately with a message if there is one, or an error if the channel is empty or disconnected.

If called on a zero-capacity channel, this method will receive a message only if there happens to be a send operation on the other side of the channel at the same time.

Examples

use crossbeam_channel::{unbounded, TryRecvError};

let (tx, rx) = unbounded();
assert_eq!(rx.try_recv(), Err(TryRecvError::Empty));

tx.send(5).unwrap();
drop(tx);

assert_eq!(rx.try_recv(), Ok(5));
assert_eq!(rx.try_recv(), Err(TryRecvError::Disconnected));

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

Waits for a message to be received from the channel.

This method will always block in order to wait for a message to become available. If the channel is (or becomes) empty and disconnected, this call will wake up and return an error.

If called on a zero-capacity channel, this method will wait for a send operation to appear on the other side of the channel.

Examples

use std::thread;
use std::time::Duration;
use crossbeam_channel::unbounded;

let (tx, rx) = unbounded();

thread::spawn(move || {
    thread::sleep(Duration::from_secs(1));
    tx.send(5).unwrap();
    drop(tx);
});

assert_eq!(rx.recv(), Ok(5));
assert!(rx.recv().is_err());

fn recv_timeout(&self, timeout: Duration) -> Result<T, RecvTimeoutError>

Waits for a message to be received from the channel but only for a limited time.

This method will always block in order to wait for a message to become available. If the channel is (or becomes) empty and disconnected, or if it waits for longer than timeout, it will wake up and return an error.

If called on a zero-capacity channel, this method will wait for a send operation to appear on the other side of the channel.

Examples

use std::thread;
use std::time::Duration;
use crossbeam_channel::{unbounded, RecvTimeoutError};

let (tx, rx) = unbounded();

thread::spawn(move || {
    thread::sleep(Duration::from_secs(1));
    tx.send(5).unwrap();
    drop(tx);
});

assert_eq!(rx.recv_timeout(Duration::from_millis(500)), Err(RecvTimeoutError::Timeout));
assert_eq!(rx.recv_timeout(Duration::from_secs(1)), Ok(5));
assert_eq!(rx.recv_timeout(Duration::from_secs(1)), Err(RecvTimeoutError::Disconnected));

fn is_empty(&self) -> bool

Returns true if the channel is empty.

Zero-capacity channels are always empty.

Examples

use crossbeam_channel::unbounded;

let (tx, rx) = unbounded();
assert!(rx.is_empty());

tx.send(0).unwrap();
assert!(!rx.is_empty());

// Drop the only sender, thus disconnecting the channel.
drop(tx);
// Even a disconnected channel can be non-empty.
assert!(!rx.is_empty());

fn len(&self) -> usize

Returns the number of messages in the channel.

Examples

use crossbeam_channel::unbounded;

let (tx, rx) = unbounded();
assert_eq!(rx.len(), 0);

tx.send(1).unwrap();
tx.send(2).unwrap();
assert_eq!(rx.len(), 2);

fn capacity(&self) -> Option<usize>

If the channel is bounded, returns its capacity.

Examples

use crossbeam_channel::{bounded, unbounded};

let (tx, _) = unbounded::<i32>();
assert_eq!(tx.capacity(), None);

let (tx, _) = bounded::<i32>(5);
assert_eq!(tx.capacity(), Some(5));

let (tx, _) = bounded::<i32>(0);
assert_eq!(tx.capacity(), Some(0));

fn is_disconnected(&self) -> bool

Returns true if the channel is disconnected (i.e. there are no senders).

Examples

use crossbeam_channel::unbounded;

let (tx, rx) = unbounded::<i32>();
assert!(!rx.is_disconnected());
drop(tx);
assert!(rx.is_disconnected());

fn iter(&self) -> Iter<T>

Returns an iterator that waits for messages until the channel is disconnected.

Each call to next will block waiting for the next message. It will finally return None when the channel is empty and disconnected.

Examples

use std::thread;
use crossbeam_channel::unbounded;

let (tx, rx) = unbounded::<i32>();

thread::spawn(move || {
    tx.send(1).unwrap();
    tx.send(2).unwrap();
    tx.send(3).unwrap();
});

let v: Vec<_> = rx.iter().collect();
assert_eq!(v, [1, 2, 3]);

fn try_iter(&self) -> TryIter<T>

Returns an iterator that receives messages until the channel is empty or disconnected.

Each call to next will return a message if there is at least one in the channel. The iterator will never block waiting for new messages.

Examples

use std::thread;
use std::time::Duration;
use crossbeam_channel::unbounded;

let (tx, rx) = unbounded::<i32>();

thread::spawn(move || {
    thread::sleep(Duration::from_secs(1));
    tx.send(1).unwrap();
    tx.send(2).unwrap();
    thread::sleep(Duration::from_secs(2));
    tx.send(3).unwrap();
});

thread::sleep(Duration::from_secs(2));
let v: Vec<_> = rx.try_iter().collect();
assert_eq!(v, [1, 2]);

Trait Implementations

impl<T> Clone for Receiver<T>

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

impl<'a, T> IntoIterator for &'a Receiver<T>

type Item = T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> <&'a Receiver<T> as IntoIterator>::IntoIter

impl<T> IntoIterator for Receiver<T>

type Item = T

type IntoIter = IntoIter<T>

fn into_iter(self) -> <Receiver<T> as IntoIterator>::IntoIter

impl<T> Send for Receiver<T> where
    T: Send, 

impl<T> Drop for Receiver<T>

fn drop(&mut self)

impl<T> Debug for Receiver<T>

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

impl<T> Sync for Receiver<T> where
    T: Send,