Struct abi_stable::external_types::crossbeam_channel::RReceiver

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

This is supported on crate feature channels only.

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>

pub fn clone(&self) -> Self

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

Note that this allocates an RBox<_>.

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

Performs copy-assignment from source.

impl<T> Debug for RReceiver<T>

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

Formats the value using the given formatter.

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

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

Performs the conversion.

impl<T> GetStaticEquivalent_ for RReceiver<T> where
    T: __StableAbi, 

type StaticEquivalent = _static_RReceiver<__GetStaticEquivalent<T>>

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

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?

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

Creates an Iterator that receives values from the channel.

impl<T> IntoIterator for RReceiver<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = RIntoIter<T>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> RIntoIter<T>

Creates an Iterator that receives values from the channel.

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

impl<T> StableAbi for RReceiver<T> where
    T: __StableAbi, 

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

pub const LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.

pub const ABI_CONSTS: AbiConsts

const-equivalents of the associated types.

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