Struct abi_stable::external_types::crossbeam_channel::RReceiver

#[repr(C)]
pub struct RReceiver<T> { /* private fields */ }

The receiver end of a channel, which can be either bounded or unbounded.

Examples

use abi_stable::external_types::crossbeam_channel as mpmc;

let (tx, rx) = mpmc::unbounded::<&'static str>();

let join_guard = std::thread::spawn(move || {
    assert_eq!(rx.recv().unwrap(), "PING");
    assert_eq!(rx.recv().unwrap(), "PING");
    assert_eq!(rx.recv().unwrap(), "PING");
    assert_eq!(rx.recv().unwrap(), "PING");
    assert!(rx.try_recv().unwrap_err().is_empty());
});

for _ in 0..4 {
    tx.send("PING").unwrap();
}

join_guard.join().unwrap();

assert!(tx.send("").is_err());

Implementations

impl<T> RReceiver<T>

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

Blocks until a value is either received,or the the other end is disconnected.

If the channel queue is empty,this will block to receive a value.

This will return an error if the channel is disconnected.

Example

use abi_stable::external_types::crossbeam_channel as mpmc;

let (tx, rx) = mpmc::bounded::<&'static str>(3);

tx.send("J__e H____y").unwrap();
assert_eq!(rx.recv().unwrap(), "J__e H____y");

drop(tx);
assert!(rx.recv().is_err());

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

Immediately receives a value,or returns with an error.

An error will be returned in these 2 conditions:

• the channel is empty.

• the channel has been disconnected.

If the channel has a capacity of 0,it will only receive a value if the other end is calling send.

Example

use abi_stable::external_types::crossbeam_channel as mpmc;

let (tx, rx) = mpmc::bounded::<&'static str>(3);

assert!(rx.try_recv().is_err());

tx.send("D__e S_____r").unwrap();
assert_eq!(rx.try_recv().unwrap(), "D__e S_____r");

drop(tx);
assert!(rx.try_recv().is_err());

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

Blocks until a timeout to receive a value.

An error will be returned in these 2 conditions:

• A value could not be received before the timeout.

• the channel has been disconnected.

If the channel has a capacity of 0,it will only receive a value if the other end calls send before the timeout.

Example

use abi_stable::external_types::crossbeam_channel as mpmc;

use std::time::Duration;

let (tx, rx) = mpmc::bounded::<&'static str>(3);

let timeout = Duration::from_millis(1);

assert!(rx.recv_timeout(timeout).unwrap_err().is_timeout());

tx.send("D__e S_____r").unwrap();
assert_eq!(rx.recv_timeout(timeout).unwrap(), "D__e S_____r");

drop(tx);
assert!(rx.recv_timeout(timeout).unwrap_err().is_disconnected());

pub fn is_empty(&self) -> bool

Returns true if there are no values in the channel queue.

Example

use abi_stable::external_types::crossbeam_channel as mpmc;

let (tx, rx) = mpmc::bounded::<()>(1);

assert!(rx.is_empty());

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

rx.recv().unwrap();
assert!(rx.is_empty());

pub fn is_full(&self) -> bool

Returns true if the channel queue is full.

This always returns true for channels constructed with bounded(0).

Example

use abi_stable::external_types::crossbeam_channel as mpmc;

let (tx, rx) = mpmc::bounded::<()>(2);

assert!(!rx.is_full());

tx.send(()).unwrap();
assert!(!rx.is_full());

tx.send(()).unwrap();
assert!(rx.is_full());

rx.recv().unwrap();
assert!(!rx.is_full());

pub fn len(&self) -> usize

Returns the amount of values in the channel queue.

Example

use abi_stable::external_types::crossbeam_channel as mpmc;

let (tx, rx) = mpmc::bounded::<()>(2);

assert_eq!(rx.len(), 0);

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

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

rx.recv().unwrap();
assert_eq!(rx.len(), 1);

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

Returns the amount of values the channel queue can hold.

This returns None if the channel is unbounded.

Example

use abi_stable::external_types::crossbeam_channel as mpmc;

{
    let (tx, rx) = mpmc::bounded::<()>(2);
    assert_eq!(rx.capacity(), Some(2));
}
{
    let (tx, rx) = mpmc::unbounded::<()>();
    assert_eq!(rx.capacity(), None);
}

pub fn iter(&self) -> RIter<'_, T>

Creates an Iterator that receives values from the channel.

Example

use abi_stable::external_types::crossbeam_channel as mpmc;

use std::thread;

let (tx, rx) = mpmc::bounded::<usize>(1);

thread::spawn(move || {
    for i in 0..1000 {
        tx.send(i).unwrap();
    }
});

for (i, n) in rx.iter().enumerate() {
    assert_eq!(i, n);
}

Trait Implementations

impl<T> Clone for RReceiver<T>

fn clone(&self) -> Self

Clones this channel end,getting another handle into the channel.

Note that this allocates an RBox<_>.

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

Performs copy-assignment from source.

impl<T> Debug for RReceiver<T>

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

Formats the value using the given formatter.

impl<T> From<Receiver<T>> for RReceiver<T>

fn from(this: Receiver<T>) -> RReceiver<T>

Converts to this type from the input type.

impl<T> GetStaticEquivalent_ for RReceiver<T>

where T: __StableAbi,

type StaticEquivalent = _static_RReceiver<<T as GetStaticEquivalent_>::StaticEquivalent>

The 'static equivalent of Self

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

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

Creates an Iterator that receives values from the channel.

type Item = T

The type of the elements being iterated over.

type IntoIter = RIter<'a, T>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for RReceiver<T>

fn into_iter(self) -> RIntoIter<T>

Creates an Iterator that receives values from the channel.

type Item = T

The type of the elements being iterated over.

type IntoIter = RIntoIter<T>

Which kind of iterator are we turning this into?

impl<T> StableAbi for RReceiver<T>

where T: __StableAbi,

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

const LAYOUT: &'static TypeLayout = _

The layout of the type provided by implementors.

const ABI_CONSTS: AbiConsts = _

const-equivalents of the associated types.

impl<T: Send> Send for RReceiver<T>

impl<T: Send> Sync for RReceiver<T>