Struct MetaCallFuture

Source

pub struct MetaCallFuture { /* private fields */ }

Expand description

Represents MetaCallFuture. Keep in mind that it’s not supported to pass a future as an argument.

§Usage example:

Javascript Code:

function doubleValueAfterTime(value, delay) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (typeof value === 'number') {
                resolve(value * 2); // Resolves if the value is a number
            } else {
                reject('Error: The provided value is not a number.'); // Rejects if the value is not a number
            }
        }, delay);
    });
}

Calling Example:

use metacall::{MetaCallValue, MetaCallFuture, metacall};
fn runner(x: i32) {

    fn resolve(result: impl MetaCallValue, data: impl MetaCallValue) {
        println!("Resolve:: result: {:#?}, data: {:#?}", result, data); //
    }

    fn reject(error: impl MetaCallValue, data: impl MetaCallValue) {
        println!("Reject:: error: {:#?}, data: {:#?}", error, data);
    }

    let future = metacall::<MetaCallFuture>("doubleValueAfterTime", [1, 2000]).unwrap();
    future.then(resolve).catch(reject).await_fut();
}

Implementations§

Source §

impl MetaCallFuture

Source

pub fn then(self, resolve: MetaCallFutureHandler) -> Self

Adds a resolve callback.

§Usage example:

// Javascript script

function func_always_rejects(value, delay) {
    return new Promise((resolve) => {
        resolve('Resolve message.');
    });
}

Calling Example:

use metacall::{MetaCallValue, MetaCallFuture, metacall_no_args};
fn calling() {
    fn reject(result: impl MetaCallValue, _: impl MetaCallValue) {
        println!("Resolve:: {:#?}", result); // Resolve:: "Resolve message"
    }

    let future = metacall_no_args::<MetaCallFuture>("func_always_resolve").unwrap();
    future.then(resolve).catch(reject).await_fut();
}

Source

pub fn catch(self, reject: MetaCallFutureHandler) -> Self

Adds a reject callback.

§Usage example:

// Javascript script
function func_always_rejects(value, delay) {
    return new Promise((_, reject) => {
        reject('Error: Reject message.');
    });
}

Calling Example:

use metacall::{MetaCallValue, MetaCallFuture, metacall_no_args};
fn calling() {
    fn reject(error: impl MetaCallValue, _: impl MetaCallValue) {
        println!("Reject:: error: {:#?}", error); // Reject:: error: "Error: Reject message"
    }

    let future = metacall_no_args::<MetaCallFuture>("func_always_rejects").unwrap();
    future.then(resolve).catch(reject).await_fut();
}

Source

pub fn data<T: 'static>(self, data: T) -> Self

Adds data to use it inside the resolver and reject.

Example:

use metacall::{MetaCallValue, MetaCallFuture, metacall};

fn run() {
  let x = 10;
  fn resolve(result: impl MetaCallValue, data: impl MetaCallValue) {
      println!("X = {data}");
  }
    
  fn reject(result: impl MetaCallValue, data: impl MetaCallValue) {
      println!("X = {data}");
  }
     
  let future = metacall::<MetaCallFuture>("async_function", [1]).unwrap();
  future.then(resolve).catch(reject),data(x).await_fut();
}