Struct cassette::Cassette

pub struct Cassette<T>
where
    T: Future + Unpin,
{ /* private fields */ }

A single-future non-blocking executor

Implementations

impl<T> Cassette<T>

where T: Future + Unpin,

pub fn new(thing: T) -> Self

Create a new Cassette containing a single pinned future

Example

use cassette::Cassette;

struct Demo {
    lol: u32,
}

impl Demo {
    async fn entry(&mut self) {
        /* Huzzah! */
    }
}

// Make a new struct
let mut demo = Demo { lol: 100 };

// Call the entry point future, and pin it
let x = core::pin::pin!(demo.entry());

// Give the pinned future to Cassette
// for execution
let mut cm = Cassette::new(x);

pub fn poll_on(&mut self) -> Option<<T as Future>::Output>

Perform a “single step” of the future contained by this Cassette.

This is intended to be “polled to completion”, which might be for forever.

Example

use cassette::Cassette;

struct Demo {
    lol: u32,
}

impl Demo {
    async fn entry(&mut self) {
        /* Huzzah! */
    }
}

// Make a new struct
let mut demo = Demo { lol: 100 };

// Call the entry point future, and pin it
let x = core::pin::pin!(demo.entry());

// Give the pinned future to Cassette
// for execution
let mut cm = Cassette::new(x);

while cm.poll_on().is_none() { }
println!("Future done!");

Panics

This method will panic if the contained future has already been completed as Poll::Ready(_).

pub fn block_on(self) -> <T as Future>::Output

Block on the contained future forever

Panics

This method will panic if the contained future has already been completed as Poll::Ready(_).

pub fn is_done(&self) -> bool

Has the contained future resolved to Poll::Ready(_) yet?