Struct tokio::sync::oneshot::Receiver

pub struct Receiver<T> { /* fields omitted */ }

Receive a value from the associated Sender.

Instances are created by the channel function.

Implementations

impl<T> Receiver<T>

pub fn close(&mut self)

Prevents the associated Sender handle from sending a value.

Any send operation which happens after calling close is guaranteed to fail. After calling close, try_recv should be called to receive a value if one was sent before the call to close completed.

This function is useful to perform a graceful shutdown and ensure that a value will not be sent into the channel and never received.

Examples

Prevent a value from being sent

use tokio::sync::oneshot;
use tokio::sync::oneshot::error::TryRecvError;

#[tokio::main]
async fn main() {
    let (tx, mut rx) = oneshot::channel();

    assert!(!tx.is_closed());

    rx.close();

    assert!(tx.is_closed());
    assert!(tx.send("never received").is_err());

    match rx.try_recv() {
        Err(TryRecvError::Closed) => {}
        _ => unreachable!(),
    }
}

Receive a value sent before calling close

use tokio::sync::oneshot;

#[tokio::main]
async fn main() {
    let (tx, mut rx) = oneshot::channel();

    assert!(tx.send("will receive").is_ok());

    rx.close();

    let msg = rx.try_recv().unwrap();
    assert_eq!(msg, "will receive");
}

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

Attempts to receive a value.

If a pending value exists in the channel, it is returned. If no value has been sent, the current task will not be registered for future notification.

This function is useful to call from outside the context of an asynchronous task.

Return

• Ok(T) if a value is pending in the channel.
• Err(TryRecvError::Empty) if no value has been sent yet.
• Err(TryRecvError::Closed) if the sender has dropped without sending a value.

Examples

try_recv before a value is sent, then after.

use tokio::sync::oneshot;
use tokio::sync::oneshot::error::TryRecvError;

#[tokio::main]
async fn main() {
    let (tx, mut rx) = oneshot::channel();

    match rx.try_recv() {
        // The channel is currently empty
        Err(TryRecvError::Empty) => {}
        _ => unreachable!(),
    }

    // Send a value
    tx.send("hello").unwrap();

    match rx.try_recv() {
        Ok(value) => assert_eq!(value, "hello"),
        _ => unreachable!(),
    }
}

try_recv when the sender dropped before sending a value

use tokio::sync::oneshot;
use tokio::sync::oneshot::error::TryRecvError;

#[tokio::main]
async fn main() {
    let (tx, mut rx) = oneshot::channel::<()>();

    drop(tx);

    match rx.try_recv() {
        // The channel will never receive a value.
        Err(TryRecvError::Closed) => {}
        _ => unreachable!(),
    }
}

Trait Implementations

impl<T: Debug> Debug for Receiver<T>

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

Formats the value using the given formatter.

impl<T> Drop for Receiver<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Future for Receiver<T>

type Output = Result<T, RecvError>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.