Struct Receiver

pub struct Receiver<T> { pub(in ::sync::oneshot) inner: 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();
});

Fields

inner: Receiver<T>

The oneshot channel is simply a wrapper around a mpmc channel.

Implementations

impl<T> Receiver<T>

fn recv(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) -> 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, 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, 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!"),
}

Trait Implementations

impl<T> Debug for Receiver<T>

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

impl<T> Sync for Receiver<T>

Auto Trait Implementations

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

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

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

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

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

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

Blanket Implementations

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

impl<T> From<T> for Receiver<T>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> SizeHint for Receiver<T> where T: ?Sized,

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

impl<T> SizedTypeProperties for Receiver<T>

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

fn into(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<U> for Receiver<T> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

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

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