Struct RawReceiver 

pub struct RawReceiver<T: Send + 'static> { /* private fields */ }

Receives a single value from the sender connected to the same event.

Awaiting the receiver will yield either the payload of type T or a Disconnected error.

This kind of endpoint is used with events for which the storage is provided by the owner of the endpoint. They are also responsible for ensuring that the event that connects the sender-receiver pair outlives both endpoints.

Implementations

impl<T: Send + 'static> RawReceiver<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<T, IntoValueError<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

use events_once::{Event, IntoValueError};

#[tokio::main]
async fn main() {
    let (sender, receiver) = Event::<String>::boxed();

    // into_value() is designed for synchronous scenarios where you do not want to wait but
    // simply want to either obtain the received value or do nothing. First, we do nothing.
    //
    // If no value has been sent yet, into_value() returns Err(IntoValueError::Pending(self)).
    let Err(IntoValueError::Pending(receiver)) = receiver.into_value() else {
        panic!(
            "Expected receiver to indicate that it is still waiting for a payload to be sent."
        );
    };

    sender.send("Hello, world!".to_string());

    let message = receiver.into_value().unwrap();

    println!("Received message: {message}");
}

Trait Implementations

impl<T: Send + 'static> Debug for RawReceiver<T>

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

Formats the value using the given formatter.

impl<T: Send + 'static> Future for RawReceiver<T>

type Output = Result<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.