Struct LocalOnceReceiver 

pub struct LocalOnceReceiver<E>
where
    E: LocalEventRef<<E as ReflectiveT>::T>,
{ /* private fields */ }

A receiver that can receive a single value through a single-threaded event.

The type of the value is the inner type parameter, i.e. the T in LocalOnceReceiver<ArcEvent<T>>.

The outer type parameter determines the mechanism by which the endpoint is bound to the event. Different binding mechanisms offer different performance characteristics and resource management patterns.

Implementations

impl<E> LocalOnceReceiver<E>

where E: LocalEventRef<<E as ReflectiveT>::T>,

pub fn is_ready(&self) -> bool

Checks whether a value is ready to be received.

Panics

Panics if called after poll() has returned Ready.

pub fn into_value(self) -> Result<Result<E::T, Disconnected>, Self>

Consumes the receiver and transforms it into the received value, if the value is available.

This method provides an alternative to awaiting the receiver when you want to check for an immediately available value without blocking. It returns Ok(value) if a value has already been sent, or returns the receiver if no value is currently available.

Panics

Panics if the value has already been received via Future::poll().

Examples

Basic usage with immediate value

use events::LocalOnceEvent;

let (sender, receiver) = LocalOnceEvent::<String>::new_managed();
sender.send("Hello".to_string());

// Value is immediately available
let value = receiver.into_value().unwrap();
assert_eq!(value, Ok("Hello".to_string()));

No value available

use events::LocalOnceEvent;

let (_sender, receiver) = LocalOnceEvent::<i32>::new_managed();

// No value sent yet - receiver is returned back
let result = receiver.into_value();
match result {
    Err(receiver) => {
        // Can retry or await the receiver
    }
    _ => panic!("Unexpected result"),
}

Sender disconnected without sending

use events::{Disconnected, LocalOnceEvent};

let (sender, receiver) = LocalOnceEvent::<String>::new_managed();
drop(sender); // Disconnect without sending

let result = receiver.into_value();
match result {
    Ok(Err(Disconnected)) => {
        // Sender disconnected, no value will ever be available
    }
    _ => panic!("Unexpected result"),
}

Trait Implementations

impl<E> Debug for LocalOnceReceiver<E>

where E: LocalEventRef<<E as ReflectiveT>::T> + Debug,

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

Formats the value using the given formatter.

impl<E> Drop for LocalOnceReceiver<E>

where E: LocalEventRef<<E as ReflectiveT>::T>,

fn drop(&mut self)

Executes the destructor for this type.

impl<E> Future for LocalOnceReceiver<E>

where E: LocalEventRef<<E as ReflectiveT>::T>,

type Output = Result<<E as ReflectiveT>::T, Disconnected>

The type of value produced on completion.

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

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