Struct quickjs_runtime::esvalue::EsPromise

pub struct EsPromise { /* fields omitted */ }

can be used to create a new Promise which is resolved with the resolver function

Example

use quickjs_runtime::esruntimebuilder::EsRuntimeBuilder;
use quickjs_runtime::esvalue::{EsPromise, EsValueConvertible};
use std::time::Duration;
use quickjs_runtime::esscript::EsScript;
use log::LevelFilter;

let rt = EsRuntimeBuilder::new().build();
rt.set_function(vec!["my", "comp"], "create_prom", |_q_ctx, _args| {
    Ok(EsPromise::new(|| {
        std::thread::sleep(Duration::from_secs(1));
        Ok(9463.to_es_value_facade())
    }).to_es_value_facade())
});
rt.eval_sync(EsScript::new("test_prom.es", "let p765 = my.comp.create_prom(); p765.then((p_res) => {console.log('got ' + p_res)});")).ok().expect("script failed");
std::thread::sleep(Duration::from_secs(2));

Implementations

impl EsPromise

pub fn new<R>(resolver: R) -> Self where
    R: FnOnce() -> Result<EsValueFacade, String> + Send + 'static, 

pub fn new_unresolving() -> Self

create a new Promise which will be resolved later this achieved by creating a Handle which is wrapped in an Arc and thus may be passed to another thread

Example

use quickjs_runtime::esruntimebuilder::EsRuntimeBuilder;
use quickjs_runtime::esscript::EsScript;
use std::time::Duration;
use quickjs_runtime::esvalue::{EsPromise, EsValueConvertible};
let rt = EsRuntimeBuilder::new().build();
// prep a function which reacts to a promise
rt.eval_sync(EsScript::new("new_unresolving.es", "this.new_unresolving = function(prom){prom.then((res) => {console.log('promise resolved to %s', res);});};")).ok().expect("script failed");
// prep a EsPromise object
let prom = EsPromise::new_unresolving();
// get the handle
let prom_handle = prom.get_handle();
// call the function with the promise as arg
rt.call_function(vec![], "new_unresolving", vec![prom.to_es_value_facade()]);
// start a new thread which resolves the handler after x seconds
std::thread::spawn(move || {
    std::thread::sleep(Duration::from_secs(3));
    prom_handle.resolve("hello there".to_string().to_es_value_facade());
});
// wait a few secs to see the log output
std::thread::sleep(Duration::from_secs(5));

pub fn get_handle(&self) -> Arc<EsPromiseResolvableHandle>

get the handle which can be used to resolve a promise

Trait Implementations

impl EsValueConvertible for EsPromise

fn as_js_value(&mut self, q_ctx: &QuickJsContext) -> Result<JSValueRef, EsError>

fn to_es_value_facade(self) -> EsValueFacade where
    Self: Sized + Send + 'static, 

fn is_null(&self) -> bool

fn is_undefined(&self) -> bool

fn is_bool(&self) -> bool

fn get_bool(&self) -> bool

fn is_str(&self) -> bool

fn get_str(&self) -> &str

fn is_i32(&self) -> bool

fn get_i32(&self) -> i32

fn is_f64(&self) -> bool

fn get_f64(&self) -> f64

fn is_function(&self) -> bool

fn invoke_function_sync(
    &self,
    _args: Vec<EsValueFacade>
) -> Result<EsValueFacade, EsError>

fn invoke_function(&self, _args: Vec<EsValueFacade>) -> Result<(), EsError>

fn invoke_function_batch_sync(
    &self,
    _args: Vec<Vec<EsValueFacade>>
) -> Vec<Result<EsValueFacade, EsError>>

fn invoke_function_batch(
    &self,
    _args: Vec<Vec<EsValueFacade>>
) -> Result<(), EsError>

fn is_promise(&self) -> bool

fn await_promise_blocking(
    &self,
    _timeout: Duration
) -> Result<Result<EsValueFacade, EsValueFacade>, RecvTimeoutError>

fn add_promise_reactions(
    &self,
    _then: PromiseReactionType,
    _catch: PromiseReactionType,
    _finally: Option<Box<dyn Fn() + Send + 'static>>
) -> Result<(), EsError>

fn is_object(&self) -> bool

fn get_object(&self) -> &HashMap<String, EsValueFacade>

fn get_object_mut(&mut self) -> &mut HashMap<String, EsValueFacade>

fn is_array(&self) -> bool

fn get_array(&self) -> &Vec<EsValueFacade>

fn get_array_mut(&mut self) -> &mut Vec<EsValueFacade>