Struct quickjs_runtime::facades::QuickjsRuntimeFacadeInner

pub struct QuickjsRuntimeFacadeInner { /* private fields */ }

Implementations

impl QuickjsRuntimeFacadeInner

pub fn add_task_to_event_loop_void<C>(&self, task: C) where
    C: FnOnce() + Send + 'static, 

this can be used to run a function in the event_queue thread for the QuickJSRuntime without borrowing the q_js_rt

pub fn exe_task_in_event_loop<C, R: Send + 'static>(&self, task: C) -> R where
    C: FnOnce() -> R + Send + 'static, 

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

pub fn add_rt_task_to_event_loop<C, R: Send + 'static>(
    &self,
    consumer: C
) -> impl Future<Output = R> where
    C: FnOnce(&QuickJsRuntimeAdapter) -> R + Send + 'static, 

this is how you add a closure to the worker thread which has an instance of the QuickJsRuntime this will run asynchronously

example

use quickjs_runtime::builder::QuickJsRuntimeBuilder;
let rt = QuickJsRuntimeBuilder::new().build();
rt.add_rt_task_to_event_loop(|q_js_rt| {
    // here you are in the worker thread and you can use the quickjs_utils
    q_js_rt.gc();
});

pub fn add_rt_task_to_event_loop_void<C>(&self, consumer: C) where
    C: FnOnce(&QuickJsRuntimeAdapter) + Send + 'static, 

pub fn exe_rt_task_in_event_loop<C, R: Send + 'static>(&self, consumer: C) -> R where
    C: FnOnce(&QuickJsRuntimeAdapter) -> R + Send + 'static, 

Trait Implementations

impl JsRuntimeFacadeInner for QuickjsRuntimeFacadeInner

type JsRuntimeFacadeType = QuickJsRuntimeFacade

fn js_exe_rt_task_in_event_loop<R: Send + 'static, J: FnOnce(&<<Self as JsRuntimeFacadeInner>::JsRuntimeFacadeType as JsRuntimeFacade>::JsRuntimeAdapterType) -> R + Send + 'static>(
    &self,
    task: J
) -> R

run a closure in the EventLoop with a &JsRuntimeAdapter as only param and await the result blocking

fn js_add_rt_task_to_event_loop<R: Send + 'static, J: FnOnce(&<<Self as JsRuntimeFacadeInner>::JsRuntimeFacadeType as JsRuntimeFacade>::JsRuntimeAdapterType) -> R + Send + 'static>(
    &self,
    task: J
) -> Pin<Box<dyn Future<Output = R> + Send>>

run a closure in the EventLoop with a &JsRuntimeAdapter as only param and return a future which will fulfill after the closure has been called

fn js_add_rt_task_to_event_loop_void<J: FnOnce(&<<Self as JsRuntimeFacadeInner>::JsRuntimeFacadeType as JsRuntimeFacade>::JsRuntimeAdapterType) + Send + 'static>(
    &self,
    task: J
)

run a closure in the EventLoop with a &JsRuntimeAdapter as only param