pub struct Receiver<T> { /* fields omitted */ }
The receiving side of a channel.
use std::thread;
use std::time::Duration;
use crossbeam_channel::unbounded;
let (s, r) = unbounded();
thread::spawn(move || {
s.send(1);
thread::sleep(Duration::from_secs(1));
s.send(2);
});
assert_eq!(r.recv(), Ok(1));
assert_eq!(r.recv(), Ok(2));
Attempts to receive a message from the channel without blocking.
This method will either receive a message from the channel immediately or return an error
if the channel is empty.
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.
use crossbeam_channel::{unbounded, TryRecvError};
let (s, r) = unbounded();
assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
s.send(5).unwrap();
drop(s);
assert_eq!(r.try_recv(), Ok(5));
assert_eq!(r.try_recv(), Err(TryRecvError::Disconnected));
Blocks the current thread until a message is received or the channel is empty and
disconnected.
If the channel is empty and not disconnected, this call will block until the receive
operation can proceed. If the channel is empty and becomes 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.
use std::thread;
use std::time::Duration;
use crossbeam_channel::{unbounded, RecvError};
let (s, r) = unbounded();
thread::spawn(move || {
thread::sleep(Duration::from_secs(1));
s.send(5).unwrap();
drop(s);
});
assert_eq!(r.recv(), Ok(5));
assert_eq!(r.recv(), Err(RecvError));
Waits for a message to be received from the channel, but only for a limited time.
If the channel is empty and not disconnected, this call will block until the receive
operation can proceed or the operation times out. If the channel is empty and becomes
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.
use std::thread;
use std::time::Duration;
use crossbeam_channel::{unbounded, RecvTimeoutError};
let (s, r) = unbounded();
thread::spawn(move || {
thread::sleep(Duration::from_secs(1));
s.send(5).unwrap();
drop(s);
});
assert_eq!(
r.recv_timeout(Duration::from_millis(500)),
Err(RecvTimeoutError::Timeout),
);
assert_eq!(
r.recv_timeout(Duration::from_secs(1)),
Ok(5),
);
assert_eq!(
r.recv_timeout(Duration::from_secs(1)),
Err(RecvTimeoutError::Disconnected),
);
Returns true
if the channel is empty.
Note: Zero-capacity channels are always empty.
use crossbeam_channel::unbounded;
let (s, r) = unbounded();
assert!(r.is_empty());
s.send(0).unwrap();
assert!(!r.is_empty());
Returns true
if the channel is full.
Note: Zero-capacity channels are always full.
use crossbeam_channel::bounded;
let (s, r) = bounded(1);
assert!(!r.is_full());
s.send(0).unwrap();
assert!(r.is_full());
Returns the number of messages in the channel.
use crossbeam_channel::unbounded;
let (s, r) = unbounded();
assert_eq!(r.len(), 0);
s.send(1).unwrap();
s.send(2).unwrap();
assert_eq!(r.len(), 2);
If the channel is bounded, returns its capacity.
use crossbeam_channel::{bounded, unbounded};
let (_, r) = unbounded::<i32>();
assert_eq!(r.capacity(), None);
let (_, r) = bounded::<i32>(5);
assert_eq!(r.capacity(), Some(5));
let (_, r) = bounded::<i32>(0);
assert_eq!(r.capacity(), Some(0));
A blocking iterator over messages in the channel.
Each call to next
blocks waiting for the next message and then returns it. However, if
the channel becomes empty and disconnected, it returns None
without blocking.
use std::thread;
use crossbeam_channel::unbounded;
let (s, r) = unbounded();
thread::spawn(move || {
s.send(1).unwrap();
s.send(2).unwrap();
s.send(3).unwrap();
drop(s);
});
let v: Vec<_> = r.iter().collect();
assert_eq!(v, [1, 2, 3]);
A non-blocking iterator over messages in the channel.
Each call to next
returns a message if there is one ready to be received. The iterator
never blocks waiting for the next message.
use std::thread;
use std::time::Duration;
use crossbeam_channel::unbounded;
let (s, r) = unbounded::<i32>();
thread::spawn(move || {
s.send(1).unwrap();
thread::sleep(Duration::from_secs(1));
s.send(2).unwrap();
thread::sleep(Duration::from_secs(2));
s.send(3).unwrap();
});
thread::sleep(Duration::from_secs(2));
let v: Vec<_> = r.try_iter().collect();
assert_eq!(v, [1, 2]);
Performs copy-assignment from source
. Read more
Executes the destructor for this type. Read more
type Item = T
The type of the elements being iterated over.
Which kind of iterator are we turning this into?
type Item = T
The type of the elements being iterated over.
Which kind of iterator are we turning this into?
Formats the value using the given formatter. Read more
Creates owned data from borrowed data, usually by cloning. Read more
🔬 This is a nightly-only experimental API. (toowned_clone_into
)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more
The type of the elements being iterated over.
Which kind of iterator are we turning this into?
🔬 This is a nightly-only experimental API. (try_from
)
The type returned in the event of a conversion error.
🔬 This is a nightly-only experimental API. (try_from
)
Immutably borrows from an owned value. Read more
🔬 This is a nightly-only experimental API. (get_type_id
)
this method will likely be replaced by an associated static
🔬 This is a nightly-only experimental API. (try_from
)
The type returned in the event of a conversion error.
🔬 This is a nightly-only experimental API. (try_from
)
Mutably borrows from an owned value. Read more