Struct async_fuse::Heap

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

A fusing adapter that stores a pinned value on the heap.

See Heap::new for more details.

Implementations

impl<T> Heap<T>

pub fn new(value: T) -> Self

Construct a fusing adapter that stores a pinned value on the heap.

For most operations except [poll_inner], if the value 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());

pub async fn poll_inner<P, O>(&mut self, poll: P) -> O where
    P: FnMut(Pin<&mut T>, &mut Context<'_>) -> Poll<O>, 

Poll the current value with the given polling implementation.

This can be used for types which only provides a polling function.

This will never empty the underlying value.

Examples

use tokio::sync::mpsc;
use std::future::Future;

async fn op(n: u32) -> u32 {
    n
}

let mut op1 = async_fuse::Heap::new(op(1));

assert_eq!(op1.poll_inner(|mut i, cx| i.poll(cx)).await, 1);
assert!(!op1.is_empty());

op1.set(op(2));
assert_eq!(op1.poll_inner(|mut i, cx| i.poll(cx)).await, 2);
assert!(!op1.is_empty());

pub async fn poll_future<P, O>(&mut self, poll: P) -> O where
    P: FnMut(Pin<&mut T>, &mut Context<'_>) -> Poll<O>, 

Poll the current value with the given polling implementation.

This can be used for types which only provides a polling function.

Once the underlying poll impl returns Poll::Ready, the underlying value will be emptied.

Examples

use tokio::sync::mpsc;
use std::future::Future;

async fn op(n: u32) -> u32 {
    n
}

let mut op1 = async_fuse::Heap::new(op(1));

assert_eq!(op1.poll_future(|mut i, cx| i.poll(cx)).await, 1);
assert!(op1.is_empty());

op1.set(op(2));
assert!(!op1.is_empty());
assert_eq!(op1.poll_future(|mut i, cx| i.poll(cx)).await, 2);
assert!(op1.is_empty());

pub async fn poll_stream<P, O>(&mut self, poll: P) -> Option<O> where
    P: FnMut(Pin<&mut T>, &mut Context<'_>) -> Poll<Option<O>>, 

Poll the current value with the given polling implementation.

This can be used for types which only provides a polling function, or types which can be polled multiple streams. Like streams which do not provide a Stream implementation.

Will empty the fused value once the underlying poll returns Poll::Ready(None).

Examples

use tokio::sync::mpsc;
use std::future::Future;
use futures_core::Stream;

fn op(n: u32) -> impl Stream<Item = u32> {
    async_stream::stream! {
        yield n;
        yield n + 1;
    }
}

let mut op1 = async_fuse::Heap::new(op(1));

assert!(!op1.is_empty());
assert_eq!(op1.poll_stream(|mut i, cx| i.poll_next(cx)).await, Some(1));
assert_eq!(op1.poll_stream(|mut i, cx| i.poll_next(cx)).await, Some(2));
assert!(!op1.is_empty());
assert_eq!(op1.poll_stream(|mut i, cx| i.poll_next(cx)).await, None);
assert!(op1.is_empty());

pub async fn next(&mut self) -> Option<T::Item> where
    Self: Unpin,
    T: Stream, 

Poll the next value in the stream where the underlying value is unpin.

Behaves the same as [poll_stream], except that it only works for values which are Unpin.

Examples

use tokio::sync::mpsc;
use std::future::Future;
use futures_core::Stream;

fn op(n: u32) -> impl Stream<Item = u32> {
    async_stream::stream! {
        yield n;
        yield n + 1;
    }
}

let mut stream = async_fuse::Heap::new(op(1));
assert!(!stream.is_empty());

assert_eq!(stream.next().await, Some(1));
assert_eq!(stream.next().await, Some(2));
assert_eq!(stream.next().await, None);

assert!(stream.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.