Struct de_net::tasks::communicator::channels::ConnErrorReceiver

pub struct ConnErrorReceiver(pub(crate) Receiver<ConnectionError>);

Channel into networking stack tasks, used for receiving connection errors.

This channel is based on a bounded queue; therefore, the non-receiving of errors can eventually block the networking stack.

If the connection errors are not needed, this channel can be safely dropped. Its closure does not stop or block any part of the networking stack. Although it must be dropped for the networking stack to fully terminate.

Tuple Fields

0: Receiver<ConnectionError>

Methods from Deref<Target = Receiver<ConnectionError>>

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));

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));

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));

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));

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());

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());

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());

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);

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);

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);

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);

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

Downgrade the receiver to a weak reference.

Trait Implementations

impl Deref for ConnErrorReceiver

type Target = Receiver<ConnectionError>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.