Enum Submission 

pub enum Submission<Ps> {
    Added(TaskInf<Ps>),
    Updated(TaskInf<Ps>),
}

Represents how a value was inserted into the system or queue.

Variants

Added(TaskInf<Ps>)

• Added: The task ID was not present; a new task was inserted.

Updated(TaskInf<Ps>)

• Updated: The task ID already existed; the existing task was updated.

Implementations

impl<Ps> Submission<Ps>

pub const fn take(self) -> TaskInf<Ps>

Consumes self and returns the inner TaskInf<Ps>.

Examples found in repository

examples/spsc.rs (line 40)

fn produce_task(submitter:TaskSubmitter) {
    prompt("hello");
    submitter.submit((||println!("consmue task='hello': hello everyone!")).into_task());

    prompt("exit");
    let id_exit = submitter.submit((|a:i32|println!("consume task='exit': recv cond={a} and exit.")).into_exit_task())
        .take();

    prompt("add");
    let id_add = submitter.submit(
        (|a:i32,b:i32|{
            println!("consume task='add': ({a},{b}) and then pass (r={}) to Task='exit'",a+b);
            a+b
        }).into_task().bind_to(id_exit.input_ca::<0>())
    ).take();

    prompt("params");
    let _ = submitter.submit(
        (||{println!("consume task='params': pass (1,2) to task='add'");1},10.into())
        .into_task()
        .map_tuple_with(move|_:i32| (1,2))
        .bind_all_to((id_add.input_ca::<0>(),id_add.input_ca::<1>()))
    );
}

examples/simple.rs (line 26)

fn main() {
    println!("----- test task orch -----");

    // Step#1. create a Pool
    let mut pool = Pool::new();

    // Step#2. create a queue
    let qid = pool.insert_queue(&Queue::new()).unwrap();
    let submitter = pool.task_submitter(qid).unwrap();

    // Step#3. create tasks

    // an indepent task
    let task = (|| println!("task='free':  Hello, 1 2 3 ..")).into_task();
    let _ = submitter.submit(task);

    // an exit task with cond(#0 i32, #1 str)
    let exit = submitter
        .submit(
            (|a: i32, msg: &str| println!("task='exit': received ({a},{msg:?}) and EXIT"))
                .into_exit_task(),
        )
        .take();

    // N->1 : pass i32 to exit-task.p0
    let b1 = (|a: i32| {
        println!("task='B1':  pass ('{a}') to task='exit'");
        a
    })
    .into_task()
    .bind_to(exit.input_ca::<0>());
    let b1 = submitter.submit(b1).take();

    // N->1 : pass str to exit task.p1
    let b2 = (|msg: &'static str| {
        println!("task='B2':  recv ('{msg}') and then pass ('{msg}') to task='exit'");
        msg
    })
    .into_task()
    .bind_to(exit.input_ca::<1>());
    let b2 = submitter.submit(b2).take();

    // 1->N : map result to task-b1 and task-b2
    let b3 = (||())
        .into_task()
        .map_tuple_with(move |_: ()| {
            println!("task='A': map `()=>(i32,&str)` and then pass (10,'exit') to task=['B1','B2']");
            (10, "exit")
        })
        .bind_all_to((b1.input_ca::<0>(), b2.input_ca::<0>()));
    let _ = submitter.submit(b3);

    // Step#4. start a thread and run
    pool.spawn_thread_for(qid);

    // Step#5. wait until all finished
    pool.join();
}

Trait Implementations

impl<Ps: Debug> Debug for Submission<Ps>

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

Formats the value using the given formatter.