Struct minimal_executor::LocalPool

pub struct LocalPool<'a, Ret = ()> { /* fields omitted */ }

A single-threaded task pool for polling futures to completion.

This executor allows you to multiplex any number of tasks onto a single thread. It’s appropriate to poll strictly I/O-bound futures that do very little work in between I/O actions.

To get a handle to the pool that implements Spawn, use the spawner() method. Because the executor is single-threaded, it supports a special form of task spawning for non-Send futures, via spawn_local_obj.

Implementations

impl<'a, Ret> LocalPool<'a, Ret>

pub fn new() -> Self

Create a new, empty pool of tasks.

pub fn spawner(&mut self) -> Spawner<'a, Ret>

pub fn spawn<F>(&mut self, f: F) where
    F: Into<LocalFutureObj<'a, Ret>>, 

pub fn run(&mut self) -> Vec<Ret>

Run all tasks in the pool to completion.

use futures::executor::LocalPool;

let mut pool = LocalPool::new();

// ... spawn some initial tasks using `spawn.spawn()` or `spawn.spawn_local()`

// run *all* tasks in the pool to completion, including any newly-spawned ones.
pool.run();

The function will block the calling thread until all tasks in the pool are complete, including any spawned while running existing tasks.

pub fn try_run_one(&mut self) -> Poll<Ret>

Runs all tasks and returns after completing one future or until no more progress can be made. Returns true if one future was completed, false otherwise.

use futures::executor::LocalPool;
use futures::task::LocalSpawnExt;
use futures::future::{ready, pending};

let mut pool = LocalPool::new();
let spawner = pool.spawner();

spawner.spawn_local(ready(())).unwrap();
spawner.spawn_local(ready(())).unwrap();
spawner.spawn_local(pending()).unwrap();

// Run the two ready tasks and return true for them.
pool.try_run_one(); // returns true after completing one of the ready futures
pool.try_run_one(); // returns true after completing the other ready future

// the remaining task can not be completed
assert!(!pool.try_run_one()); // returns false

This function will not block the calling thread and will return the moment that there are no tasks left for which progress can be made or after exactly one task was completed; Remaining incomplete tasks in the pool can continue with further use of one of the pool’s run or poll methods. Though only one task will be completed, progress may be made on multiple tasks.

pub fn poll_once(&mut self) -> Poll<Option<Ret>>

Trait Implementations

impl<'a, Ret: Debug> Debug for LocalPool<'a, Ret>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, Ret> Default for LocalPool<'a, Ret>

fn default() -> Self

Returns the “default value” for a type.