Enum osaka::Task

pub enum Task<R> {
    Later {
        f: Box<dyn Future<R>>,
        a: Again,
    },
    Immediate {
        r: Option<R>,
    },
}

Something that can be activated

An osaka task is usually constructed by adding the osaka macro to a function, like so:

#[osaka]
fn the_answer(poll: osaka::Poll) -> u32 {
    let oracle = Oracle{};
    let token = poll.register(oracle);
    if oracle.is_ready() {
        return 42;
    } else {
        yield poll.again(token);
    }
}

Variants

Later

Fields of Later

f: Box<dyn Future<R>>a: Again

Immediate

Fields of Immediate

r: Option<R>

Methods

impl<R> Task<R>

pub fn run(&mut self) -> R

run a task to completion, blocking the current thread.

this is not re-entrant, meaning you cannot call this function from some callback. It is also not thread safe. Basically only ever call this once, prefferably in main.

pub fn new(f: Box<dyn Future<R>>, a: Again) -> Self

the brave may construct a Task manually from a Future

the passed Again instance needs to already contain an activation source, or the task will never be executed

for example:

struct Santa {
    poll: Poll
}

impl Future for Santa {
    fn poll(&mut self) -> FutureResult<Present> {
        FutureResult::Again(self.poll.never())
    }
}

fn main() {
    let poll = Poll::new();
    let santa = Santa{poll};
    santa.run().unwrap();
}

pub fn wakeup_now(&mut self)

force a wakeup the next time activate is called. This is for a poor implementation of channels and you should probably not use this.

pub fn immediate(t: R) -> Task<R>

Trait Implementations

impl<R> Future<R> for Task<R>

fn poll(&mut self) -> FutureResult<R>

this is called by the execution engine, or a sync macro.

you can call this by hand, but it won't actually do anything unless the task contains a token that is ready, or has an expired deadline

impl<E: Debug> Termination for Task<Result<(), E>>

fn report(self) -> i32

🔬 This is a nightly-only experimental API. (termination_trait_lib)

Is called to get the representation of the value as status code. This status code is returned to the operating system.