Struct Receiver

struct Receiver<T> { ... }

The receiving half of a oneshot channel.

Examples

#![feature(oneshot_channel)]
use std::sync::oneshot;
use std::thread;
use std::time::Duration;

let (sender, receiver) = oneshot::channel();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(100));
    sender.send("Hello after delay!").unwrap();
});

println!("Waiting for message...");
println!("{}", receiver.recv().unwrap());

Receiver cannot be sent between threads if it is receiving non-Send types.

# #![feature(oneshot_channel)]
# use std::sync::oneshot;
# use std::thread;
# use std::ptr;
#
let (sender, receiver) = oneshot::channel();

struct NotSend(*mut ());
sender.send(NotSend(ptr::null_mut()));

thread::spawn(move || {
    let reply = receiver.try_recv().unwrap();
});

Implementations

impl<T> Receiver<T>

fn recv(self: Self) -> Result<T, RecvError>

Receives the value from the sending end, blocking the calling thread until it gets it.

Can only fail if the corresponding [Sender<T>] has been dropped.

Examples

#![feature(oneshot_channel)]
use std::sync::oneshot;
use std::thread;
use std::time::Duration;

let (tx, rx) = oneshot::channel();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(500));
    tx.send("Done!").unwrap();
});

// This will block until the message arrives.
println!("{}", rx.recv().unwrap());

fn try_recv(self: Self) -> Result<T, TryRecvError<T>>

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

Examples

#![feature(oneshot_channel)]
use std::sync::oneshot;
use std::thread;
use std::time::Duration;

let (sender, mut receiver) = oneshot::channel();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(100));
    sender.send(42).unwrap();
});

// Keep trying until we get the message, doing other work in the process.
loop {
    match receiver.try_recv() {
        Ok(value) => {
            assert_eq!(value, 42);
            break;
        }
        Err(oneshot::TryRecvError::Empty(rx)) => {
            // Retake ownership of the receiver.
            receiver = rx;
#           fn do_other_work() { thread::sleep(Duration::from_millis(25)); }
            do_other_work();
        }
        Err(oneshot::TryRecvError::Disconnected) => panic!("Sender disconnected"),
    }
}

fn recv_timeout(self: Self, timeout: Duration) -> Result<T, RecvTimeoutError<T>>

Attempts to wait for a value on this receiver, returning an error if the corresponding Sender half of this channel has been dropped, or if it waits more than timeout.

Examples

#![feature(oneshot_channel)]
use std::sync::oneshot;
use std::thread;
use std::time::Duration;

let (sender, receiver) = oneshot::channel();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(500));
    sender.send("Success!").unwrap();
});

// Wait up to 1 second for the message
match receiver.recv_timeout(Duration::from_secs(1)) {
    Ok(msg) => println!("Received: {}", msg),
    Err(oneshot::RecvTimeoutError::Timeout(_)) => println!("Timed out!"),
    Err(oneshot::RecvTimeoutError::Disconnected) => println!("Sender dropped!"),
}

fn recv_deadline(self: Self, deadline: Instant) -> Result<T, RecvTimeoutError<T>>

Attempts to wait for a value on this receiver, returning an error if the corresponding Sender half of this channel has been dropped, or if deadline is reached.

Examples

#![feature(oneshot_channel)]
use std::sync::oneshot;
use std::thread;
use std::time::{Duration, Instant};

let (sender, receiver) = oneshot::channel();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(100));
    sender.send("Just in time!").unwrap();
});

let deadline = Instant::now() + Duration::from_millis(500);
match receiver.recv_deadline(deadline) {
    Ok(msg) => println!("Received: {}", msg),
    Err(oneshot::RecvTimeoutError::Timeout(_)) => println!("Missed deadline!"),
    Err(oneshot::RecvTimeoutError::Disconnected) => println!("Sender dropped!"),
}

impl<T> Any for Receiver<T>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Receiver<T>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Receiver<T>

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

impl<T> Debug for Receiver<T>

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

impl<T> Freeze for Receiver<T>

impl<T> From for Receiver<T>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> RefUnwindSafe for Receiver<T>

impl<T> Send for Receiver<T>

impl<T> Sync for Receiver<T>

impl<T> Unpin for Receiver<T>

impl<T> UnwindSafe for Receiver<T>

impl<T, U> Into for Receiver<T>

fn into(self: Self) -> U

Calls U::from(self).

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

impl<T, U> TryFrom for Receiver<T>

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

impl<T, U> TryInto for Receiver<T>

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