Macro rumtk_exec_task 

macro_rules! rumtk_exec_task {
    ($func:expr ) => { ... };
    ($func:expr, $args:expr ) => { ... };
    ($func:expr, $args:expr , $threads:expr ) => { ... };
}

Convenience macro for packaging the task components and launching the task in one line.

One of the advantages is that you can generate a new tokio runtime by specifying the number of threads at the end. This is optional. Meaning, we will default to the system’s number of threads if that value is not specified.

Between the func parameter and the optional threads parameter, you can specify a variable number of arguments to pass to the task. each argument must be of the same type. If you wish to pass different arguments with different types, please define an abstract type whose underlying structure is a tuple of items and pass that instead.

Examples

With Default Thread Count

    use rumtk_core::{rumtk_exec_task};
    use rumtk_core::core::RUMResult;
    use rumtk_core::threading::thread_primitives::SafeTaskArgs;

    async fn test(args: &SafeTaskArgs<i32>) -> RUMResult<Vec<i32>> {
        let mut result = Vec::<i32>::new();
        for arg in args.read().await.iter() {
            result.push(*arg);
        }
        Ok(result)
    }

    let result = rumtk_exec_task!(test, vec![5]);
    assert_eq!(&result.clone().unwrap(), &vec![5], "Results mismatch");
    assert_ne!(&result.clone().unwrap(), &vec![5, 10], "Results do not mismatch as expected!");

With Custom Thread Count

    use rumtk_core::{rumtk_exec_task};
    use rumtk_core::core::RUMResult;
    use rumtk_core::threading::thread_primitives::SafeTaskArgs;

    async fn test(args: &SafeTaskArgs<i32>) -> RUMResult<Vec<i32>> {
        let mut result = Vec::<i32>::new();
        for arg in args.read().await.iter() {
            result.push(*arg);
        }
        Ok(result)
    }

    let result = rumtk_exec_task!(test, vec![5], 5);
    assert_eq!(&result.clone().unwrap(), &vec![5], "Results mismatch");
    assert_ne!(&result.clone().unwrap(), &vec![5, 10], "Results do not mismatch as expected!");

With Async Function Body

    use rumtk_core::{rumtk_exec_task};
    use rumtk_core::core::RUMResult;
    use rumtk_core::threading::thread_primitives::SafeTaskArgs;

    let result = rumtk_exec_task!(
    async move |args: &SafeTaskArgs<i32>| -> RUMResult<Vec<i32>> {
        let mut result = Vec::<i32>::new();
        for arg in args.read().await.iter() {
            result.push(*arg);
        }
        Ok(result)
    },
    vec![5]);
    assert_eq!(&result.clone().unwrap(), &vec![5], "Results mismatch");
    assert_ne!(&result.clone().unwrap(), &vec![5, 10], "Results do not mismatch as expected!");

With Async Function Body and No Args

    use rumtk_core::{rumtk_exec_task};
    use rumtk_core::core::RUMResult;
    use rumtk_core::threading::thread_primitives::SafeTaskArgs;

    let result = rumtk_exec_task!(
    async || -> RUMResult<Vec<i32>> {
        let mut result = Vec::<i32>::new();
        Ok(result)
    });
    let empty = Vec::<i32>::new();
    assert_eq!(&result.clone().unwrap(), &empty, "Results mismatch");
    assert_ne!(&result.clone().unwrap(), &vec![5, 10], "Results do not mismatch as expected!");

Equivalent To

    use rumtk_core::{rumtk_init_threads, rumtk_resolve_task, rumtk_create_task_args, rumtk_create_task, rumtk_spawn_task};
    use rumtk_core::core::RUMResult;
    use rumtk_core::threading::thread_primitives::SafeTaskArgs;

    async fn test(args: &SafeTaskArgs<i32>) -> RUMResult<Vec<i32>> {
        let mut result = Vec::<i32>::new();
        for arg in args.read().await.iter() {
            result.push(*arg);
        }
        Ok(result)
    }

    let rt = rumtk_init_threads!();
    let args = rumtk_create_task_args!(1);
    let task = rumtk_create_task!(test, args);
    let result = rumtk_resolve_task!(&rt, rumtk_spawn_task!(&rt, task));