Struct Receiver 

pub struct Receiver<T: Send + 'static> {
    inner: *mut ChannelInner<T>,
}

The receiving half of channel type.

This half can only be owned by one thread, but it can be cloned to receive to other threads.

Messages sent to the channel can be retrieved using recv.

Fields

inner: *mut ChannelInner<T>

Implementations

impl<T: Send + 'static> Receiver<T>

fn inner<'a>(&self) -> &'a ChannelInner<T>

pub fn can_recv(&self) -> bool

Can receive a value through this channel.

pub fn has_sender(&self) -> bool

Does anyone can send a value through this channel.

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

Attempts to wait for a value on this receiver, returning an error if the corresponding channel has hung up.

This function will always block the current thread if there is no data available and it’s possible for more data to be sent. Once a message is sent to the corresponding Sender (or Sender), then this receiver will wake up and return that message.

If the corresponding Sender has disconnected, or it disconnects while this call is blocking, this call will wake up and return Err to indicate that no more messages can ever be received on this channel. However, since channels are buffered, messages sent before the disconnect will still be properly received.

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

Attempts to return a pending value on this receiver without blocking.

This method will never block the caller in order to wait for data to become available. Instead, this will always return immediately with a possible option of pending data on the channel.

This is useful for a flavor of “optimistic check” before deciding to block on a receiver.

Compared with recv, this function has two failure cases instead of one (one for disconnection, one for an empty buffer).

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

Returns an iterator that will block waiting for messages, but never panicked. It will return None when the channel has hung up.

pub fn try_iter(&self) -> TryIter<'_, T>

Returns an iterator that will attempt to yield all pending values. It will return None if there are no more pending values or if the channel has hung up. The iterator will never panicked or block the user by waiting for values.

pub fn capacity(&self) -> usize

Get capacity of the channel.

Trait Implementations

impl<T: Send + 'static> Clone for Receiver<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Send + 'static> Debug for Receiver<T>

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

Formats the value using the given formatter.

impl<T: Send + 'static> Drop for Receiver<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T: Send + 'static> IntoIterator for &'a Receiver<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

impl<T: Send + 'static> IntoIterator for Receiver<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T>

Creates an iterator from a value.

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

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