Struct async_fuse::Heap

pub struct Heap<T> { /* fields omitted */ }

Fusing adapter that is capable of polling an interior value that is being fused using a custom polling function.

See [heap_fuse] for details.

Implementations

impl<T> Heap<T>

pub fn new(value: T) -> Self where
    T: Future, 

Construct a fusing adapter that is capable of polling an interior future.

Heap the future completes, the adapter will switch to an empty state and return Poll::Pending until set again.

Examples

use std::time::Duration;
use tokio::time;

let mut sleep = async_fuse::Heap::new(time::sleep(Duration::from_millis(200)));

tokio::select! {
    _ = &mut sleep => {
        assert!(sleep.is_empty());
        sleep.set(time::sleep(Duration::from_millis(200)));
    }
}

assert!(!sleep.is_empty());

pub fn empty() -> Self

Construct an empty heap fuse.

Examples

use tokio::time;

let mut sleep = async_fuse::Heap::<time::Sleep>::empty();

assert!(sleep.is_empty());

impl<T> Heap<T>

pub fn set(&mut self, value: T)

Set the fused value.

Examples

use tokio::time;
use std::time::Duration;

let mut sleep = async_fuse::Heap::new(time::sleep(Duration::from_millis(200)));

assert!(!sleep.is_empty());
sleep.set(time::sleep(Duration::from_millis(200)));
assert!(!sleep.is_empty());

pub fn clear(&mut self)

Clear the fused value.

Examples

use tokio::time;
use std::time::Duration;

let mut sleep = async_fuse::Heap::new(time::sleep(Duration::from_millis(200)));

assert!(!sleep.is_empty());
sleep.clear();
assert!(sleep.is_empty());

pub fn is_empty(&self) -> bool

Test if the polled for value is empty.

Examples

use tokio::time;
use std::time::Duration;

let mut sleep = async_fuse::Heap::new(time::sleep(Duration::from_millis(200)));

assert!(!sleep.is_empty());
sleep.clear();
assert!(sleep.is_empty());

Trait Implementations

impl<T> Default for Heap<T>

pub fn default() -> Self

Returns the "default value" for a type.

impl<T> From<Option<T>> for Heap<T>

pub fn from(value: Option<T>) -> Self

Performs the conversion.

impl<T> Future for Heap<T> where
    T: Future, 

type Output = T::Output

The type of value produced on completion.

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

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

impl<T> Stream for Heap<T> where
    T: Stream, 

type Item = T::Item

Values yielded by the stream.

pub fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

pub fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.