Struct async_channel::Receiver

source ·
pub struct Receiver<T> { /* private fields */ }
Expand description

The receiving side of a channel.

Receivers can be cloned and shared among threads. When all receivers associated with a channel are dropped, the channel becomes closed.

The channel can also be closed manually by calling Receiver::close().

Receivers implement the [Stream] trait.

Implementations§

source§

impl<T> Receiver<T>

source

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

Attempts to receive a message from the channel.

If the channel is empty, or empty and closed, this method returns an error.

§Examples
use async_channel::{unbounded, TryRecvError};

let (s, r) = unbounded();
assert_eq!(s.send(1).await, Ok(()));

assert_eq!(r.try_recv(), Ok(1));
assert_eq!(r.try_recv(), Err(TryRecvError::Empty));

drop(s);
assert_eq!(r.try_recv(), Err(TryRecvError::Closed));
source

pub fn recv(&self) -> Recv<'_, T>

Receives a message from the channel.

If the channel is empty, this method waits until there is a message.

If the channel is closed, this method receives a message or returns an error if there are no more messages.

§Examples
use async_channel::{unbounded, RecvError};

let (s, r) = unbounded();

assert_eq!(s.send(1).await, Ok(()));
drop(s);

assert_eq!(r.recv().await, Ok(1));
assert_eq!(r.recv().await, Err(RecvError));
source

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

Receives a message from the channel using the blocking strategy.

If the channel is empty, this method waits until there is a message. If the channel is closed, this method receives a message or returns an error if there are no more messages.

§Blocking

Rather than using asynchronous waiting, like the recv method, this method will block the current thread until the message is sent.

This method should not be used in an asynchronous context. It is intended to be used such that a channel can be used in both asynchronous and synchronous contexts. Calling this method in an asynchronous context may result in deadlocks.

§Examples
use async_channel::{unbounded, RecvError};

let (s, r) = unbounded();

assert_eq!(s.send_blocking(1), Ok(()));
drop(s);

assert_eq!(r.recv_blocking(), Ok(1));
assert_eq!(r.recv_blocking(), Err(RecvError));
source

pub fn close(&self) -> bool

Closes the channel.

Returns true if this call has closed the channel and it was not closed already.

The remaining messages can still be received.

§Examples
use async_channel::{unbounded, RecvError};

let (s, r) = unbounded();
assert_eq!(s.send(1).await, Ok(()));

assert!(r.close());
assert_eq!(r.recv().await, Ok(1));
assert_eq!(r.recv().await, Err(RecvError));
source

pub fn is_closed(&self) -> bool

Returns true if the channel is closed.

§Examples
use async_channel::{unbounded, RecvError};

let (s, r) = unbounded::<()>();
assert!(!r.is_closed());

drop(s);
assert!(r.is_closed());
source

pub fn is_empty(&self) -> bool

Returns true if the channel is empty.

§Examples
use async_channel::unbounded;

let (s, r) = unbounded();

assert!(s.is_empty());
s.send(1).await;
assert!(!s.is_empty());
source

pub fn is_full(&self) -> bool

Returns true if the channel is full.

Unbounded channels are never full.

§Examples
use async_channel::bounded;

let (s, r) = bounded(1);

assert!(!r.is_full());
s.send(1).await;
assert!(r.is_full());
source

pub fn len(&self) -> usize

Returns the number of messages in the channel.

§Examples
use async_channel::unbounded;

let (s, r) = unbounded();
assert_eq!(r.len(), 0);

s.send(1).await;
s.send(2).await;
assert_eq!(r.len(), 2);
source

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

Returns the channel capacity if it’s bounded.

§Examples
use async_channel::{bounded, unbounded};

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

let (s, r) = unbounded::<i32>();
assert_eq!(r.capacity(), None);
source

pub fn receiver_count(&self) -> usize

Returns the number of receivers for the channel.

§Examples
use async_channel::unbounded;

let (s, r) = unbounded::<()>();
assert_eq!(r.receiver_count(), 1);

let r2 = r.clone();
assert_eq!(r.receiver_count(), 2);
source

pub fn sender_count(&self) -> usize

Returns the number of senders for the channel.

§Examples
use async_channel::unbounded;

let (s, r) = unbounded::<()>();
assert_eq!(r.sender_count(), 1);

let s2 = s.clone();
assert_eq!(r.sender_count(), 2);
source

pub fn downgrade(&self) -> WeakReceiver<T>

Downgrade the receiver to a weak reference.

Trait Implementations§

source§

impl<T> Clone for Receiver<T>

source§

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

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<T> Debug for Receiver<T>

source§

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

Formats the value using the given formatter. Read more
source§

impl<T> Drop for Receiver<T>

source§

fn drop(&mut self)

Executes the destructor for this type. Read more
source§

impl<T> FusedStream for Receiver<T>

source§

fn is_terminated(&self) -> bool

Returns true if the stream should no longer be polled.
source§

impl<T> Stream for Receiver<T>

§

type Item = T

Values yielded by the stream.
source§

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_> ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted. Read more
§

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream. Read more

Auto Trait Implementations§

§

impl<T> RefUnwindSafe for Receiver<T>

§

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

§

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

§

impl<T> Unpin for Receiver<T>

§

impl<T> UnwindSafe for Receiver<T>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<S, T, E> TryStream for S
where S: Stream<Item = Result<T, E>> + ?Sized,

§

type Ok = T

The type of successful values yielded by this future
§

type Error = E

The type of failures yielded by this future
§

fn try_poll_next( self: Pin<&mut S>, cx: &mut Context<'_> ) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>

Poll this TryStream as if it were a Stream. Read more