Struct async_unsync::unbounded::UnboundedChannel

pub struct UnboundedChannel<T> { /* private fields */ }

An unsynchronized (!Sync), asynchronous and unbounded channel.

Implementations

impl<T> UnboundedChannel<T>

pub fn with_initial_capacity(initial: usize) -> Self

Returns a new unbounded channel with pre-allocated initial capacity.

pub fn split( &mut self ) -> (UnboundedSenderRef<'_, T>, UnboundedReceiverRef<'_, T>)

Splits the channel into borrowing UnboundedSenderRef and UnboundedReceiverRef handles.

Examples

use async_unsync::unbounded;

// must use a non-temporary binding for the channel
let mut chan = unbounded::channel();
let (tx, mut rx) = chan.split();
tx.send(1).unwrap();

// dropping the handles will close the channel
drop((tx, rx));
assert!(chan.is_closed());

// ...but the queued value can still be received
assert_eq!(chan.try_recv(), Ok(1));
assert!(chan.try_recv().is_err());

pub fn into_split(self) -> (UnboundedSender<T>, UnboundedReceiver<T>)

Splits the channel into owning UnboundedSender and UnboundedReceiver handles.

This requires one additional allocation over split, but avoids potential lifetime restrictions, since the returned handles are valid for the 'static lifetime, meaning they can be used in spawned (local) tasks.

pub fn into_deque(self) -> VecDeque<T>

Converts into the underlying VecDeque container.

pub fn len(&self) -> usize

Returns the number of queued elements.

pub fn close(&self)

Closes the channel, ensuring that all subsequent sends will fail.

pub fn is_closed(&self) -> bool

Returns true if the channel is closed.

pub fn is_empty(&self) -> bool

Returns true if the channel is empty.

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

Receives an element through the channel.

Errors

Fails, if the channel is empty or disconnected.

pub fn poll_recv(&self, cx: &mut Context<'_>) -> Poll<Option<T>>

Polls the channel, resolving if an element was received or the channel is closed, ignoring whether there are any remaining Sender(s) or not.

pub async fn recv(&self) -> Option<T>

Receives an element through the channel.

Errors

Fails, if the channel is closed (i.e., all senders have been dropped).

pub fn send(&self, elem: T) -> Result<(), SendError<T>>

Sends a value through the channel.

Errors

Fails, if the queue is closed.

Trait Implementations

impl<T> Debug for UnboundedChannel<T>

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

Formats the value using the given formatter.

impl<T> FromIterator<T> for UnboundedChannel<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.