Struct PooledOnceReceiver 

pub struct PooledOnceReceiver<P>
where
    P: PoolRef<<P as ReflectiveTSend>::T>,
{ /* private fields */ }

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

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

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

Implementations

impl<P> PooledOnceReceiver<P>

where P: PoolRef<<P as ReflectiveTSend>::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<<P as ReflectiveTSend>::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 Some(value) if a value has already been sent, or None if no value is currently available.

Panics

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

Examples

Basic usage with Arc-based pool

use std::sync::Arc;

use events::OnceEventPool;

let pool = Arc::new(OnceEventPool::<String>::new());
let (sender, receiver) = pool.bind_by_arc();
sender.send("Hello from pool".to_string());

// Value is immediately available
let value = receiver.into_value();
assert_eq!(value.unwrap(), Ok("Hello from pool".to_string()));
// Event is automatically returned to pool for reuse

No value available

use std::sync::Arc;

use events::OnceEventPool;

let pool = Arc::new(OnceEventPool::<i32>::new());
let (_sender, receiver) = pool.bind_by_arc();

// No value sent yet - receiver is returned back
let result = receiver.into_value();
assert!(result.is_err()); // Returns Err(receiver)
// Event is still returned to pool

Using with reference-based pool binding

use events::OnceEventPool;

let pool = OnceEventPool::<String>::new();
let (sender, receiver) = pool.bind_by_ref();
sender.send("Hello".to_string());

let value = receiver.into_value().unwrap();
assert_eq!(value, Ok("Hello".to_string()));

Trait Implementations

impl<P> Debug for PooledOnceReceiver<P>

where P: PoolRef<<P as ReflectiveTSend>::T>,

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

Formats the value using the given formatter.

impl<P> Drop for PooledOnceReceiver<P>

where P: PoolRef<<P as ReflectiveTSend>::T>,

fn drop(&mut self)

Executes the destructor for this type.

impl<P> Future for PooledOnceReceiver<P>

where P: PoolRef<<P as ReflectiveTSend>::T>,

type Output = Result<<P as ReflectiveTSend>::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.

impl<P> Send for PooledOnceReceiver<P>

where P: PoolRef<<P as ReflectiveTSend>::T> + Send,