Struct hirofa_utils::eventloop::EventLoop

pub struct EventLoop { /* private fields */ }

the EventLoop struct is a single thread event queue

Implementations

impl EventLoop

pub fn new() -> Self

init a new EventLoop

pub fn is_my_pool_thread(&self) -> bool

internal method to ensure a member is called from the worker thread

pub fn is_a_pool_thread() -> bool

internal method to ensure a member is called from the worker thread

pub fn add_local_future_void<F: Future<Output = ()> + 'static>(fut: F)

add a future to the EventLoop from within a running task

pub fn add_local_future<R: Send + 'static, F: Future<Output = R> + 'static>( fut: F, ) -> impl Future<Output = R>

add a future to the EventLoop from within a running task

pub fn add_local_void<T: FnOnce() + 'static>(task: T)

add a task to the EventLoop from within a running task

pub fn add<T: FnOnce() -> R + Send + 'static, R: Send + 'static>( &self, task: T, ) -> impl Future<Output = R>

add a task to the EventLoop

pub fn exe<R: Send + 'static, T: FnOnce() -> R + Send + 'static>( &self, task: T, ) -> R

execute a task in the EventLoop and block until it completes

pub fn add_future<R: Send + 'static, F: Future<Output = R> + Send + 'static>( &self, fut: F, ) -> impl Future<Output = R>

add an async block to the EventLoop #Example

use hirofa_utils::eventloop::EventLoop;
use futures::executor::block_on;
let test_loop = EventLoop::new();
let fut = test_loop.add_future(async move {
   // this is an async block, you can .await async functions here
   123
});
let res = block_on(fut); // get result
assert_eq!(res, 123);

pub fn add_future_void<F: Future<Output = ()> + Send + 'static>(&self, fut: F)

add a Future to the pool, for when you don’t need the result #Example

use hirofa_utils::eventloop::EventLoop;
use futures::executor::block_on;
use std::sync::mpsc::channel;
let test_loop = EventLoop::new();
let (tx, rx) = channel(); // just to see if it works
let fut = test_loop.add_future(async move {
   // this is an async block, you can .await async functions here
   println!("running async here");
   tx.send(1234);
});

let res = rx.recv().expect("could not recv");
assert_eq!(res, 1234);

pub fn add_void<T: FnOnce() + Send + 'static>(&self, task: T)

add a task to the pool

pub fn add_timeout<F: FnOnce() + 'static>(task: F, delay: Duration) -> i32

add a timeout (delayed task) to the EventLoop

pub fn add_interval<F: Fn() + 'static>( task: F, delay: Duration, interval: Duration, ) -> i32

add an interval (repeated task) to the EventLoop

pub fn clear_timeout(id: i32)

cancel a previously added timeout

pub fn clear_interval(id: i32)

cancel a previously added interval

Trait Implementations

impl Debug for EventLoop

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

Formats the value using the given formatter.

impl Default for EventLoop

fn default() -> Self

Returns the “default value” for a type.

impl Drop for EventLoop

fn drop(&mut self)

Executes the destructor for this type.