Struct fibers::InPlaceExecutor

pub struct InPlaceExecutor { /* fields omitted */ }

An executor that executes spawned fibers and I/O event polling on current thread.

Examples

An example to calculate fibonacci numbers:

use fibers::{Spawn, Executor, InPlaceExecutor};
use futures::{Async, Future, BoxFuture};

fn fib<H: Spawn + Clone>(n: usize, handle: H) -> BoxFuture<usize, ()> {
    if n < 2 {
        futures::finished(n).boxed()
    } else {
        let f0 = handle.spawn_monitor(fib(n - 1, handle.clone()));
        let f1 = handle.spawn_monitor(fib(n - 2, handle.clone()));
        f0.join(f1).map(|(a0, a1)| a0 + a1).map_err(|_| ()).boxed()
    }
}

let mut executor = InPlaceExecutor::new().unwrap();
let mut monitor = executor.spawn_monitor(fib(7, executor.handle()));
loop {
    if let Async::Ready(answer) = monitor.poll().unwrap() {
        assert_eq!(answer, 13);
        return;
    } else {
        executor.run_once().unwrap();
    }
}

Methods

impl InPlaceExecutor

fn new() -> Result<Self>

Creates a new instance of InPlaceExecutor.

Trait Implementations

impl Debug for InPlaceExecutor

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Executor for InPlaceExecutor

type Handle = InPlaceExecutorHandle

The handle type of the executor.

fn handle(&self) -> Self::Handle

Returns the handle of the executor.

fn run_once(&mut self) -> Result<()>

Runs one one unit of works.

fn run_fiber<T, E>(
    &mut self,
    monitor: Monitor<T, E>
) -> Result<Result<T, MonitorError<E>>>

Runs until the monitored fiber exits.

fn run_future<F: Future>(
    &mut self,
    future: F
) -> Result<Result<F::Item, F::Error>>

Runs until the future is ready.

fn run(self) -> Result<()>

Runs infinitely until an error happens.

impl Spawn for InPlaceExecutor

fn spawn_boxed(&self, fiber: BoxFuture<(), ()>)

Spawns a fiber which will execute given boxed future.

fn spawn<F>(&self, fiber: F) where
    F: Future<Item = (), Error = ()> + Send + 'static, 

Spawns a fiber which will execute given future.

fn spawn_fn<F, T>(&self, f: F) where
    F: FnOnce() -> T + Send + 'static,
    T: IntoFuture<Item = (), Error = ()> + Send + 'static,
    T::Future: Send, 

Equivalent to self.spawn(futures::lazy(|| f())).

fn spawn_monitor<F, T, E>(&self, f: F) -> Monitor<T, E> where
    F: Future<Item = T, Error = E> + Send + 'static,
    T: Send + 'static,
    E: Send + 'static, 

Spawns a fiber and returns a future to monitor it's execution result.

fn spawn_link<F, T, E>(&self, f: F) -> Link<(), (), T, E> where
    F: Future<Item = T, Error = E> + Send + 'static,
    T: Send + 'static,
    E: Send + 'static, 

Spawns a linked fiber.

fn boxed(self) -> BoxSpawn where
    Self: Sized + Send + 'static, 

Converts this instance into a boxed object.