Struct RawPooledReceiver 

pub struct RawPooledReceiver<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 for events stored in a raw event pool or event lake.

Implementations

impl<T: Send + 'static> RawPooledReceiver<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 RawPooledReceiver<T>

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

Formats the value using the given formatter.

impl<T: Send + 'static> Future for RawPooledReceiver<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.