Struct ParallelWorkflow 

pub struct ParallelWorkflow<A, B, SA: BranchState, SB: BranchState> {
    pub branch_a: BranchToken<A, SA>,
    pub branch_b: BranchToken<B, SB>,
}

Tracks the status of two concurrent branches (A and B) at compile time.

Representation

Struct ParallelWorkflow containing branch_a and branch_b of type BranchToken<A, SA> and BranchToken<B, SB> respectively. Since both tokens are zero-sized, ParallelWorkflow is also zero-sized (0 bytes).

Structure-only

Models an AND-split/concurrency pattern between two branches without using OS threads, async futures, or mutexes.

Graduation

Graduates to wasm4pm’s parallel gateways (BPMN AND-split and AND-join, or Petri Net transitions) which manage dynamic, multi-threaded or distributed scheduling.

Fields

branch_a: BranchToken<A, SA>

branch_b: BranchToken<B, SB>

Implementations

impl<A, B> ParallelWorkflow<A, B, Pending, Pending>

pub fn split() -> Self

Initializes a parallel workflow split (AND-Split).

Examples

use wasm4pm_compat::workflow::{ParallelWorkflow, Pending};

struct TaskA;
struct TaskB;
let workflow: ParallelWorkflow<TaskA, TaskB, Pending, Pending> = ParallelWorkflow::split();

impl<A, B, SB: BranchState> ParallelWorkflow<A, B, Running, SB>

pub fn complete_a(self) -> ParallelWorkflow<A, B, Completed, SB>

Completes the task on Branch A.

Examples

use wasm4pm_compat::workflow::{ParallelWorkflow, Pending, Running, Completed};

struct TaskA;
struct TaskB;
let workflow: ParallelWorkflow<TaskA, TaskB, Pending, Pending> = ParallelWorkflow::split();
// Start both branches
let workflow = ParallelWorkflow {
    branch_a: workflow.branch_a.start(),
    branch_b: workflow.branch_b.start(),
};
// Complete branch A
let workflow: ParallelWorkflow<TaskA, TaskB, Completed, Running> = workflow.complete_a();

impl<A, B, SA: BranchState> ParallelWorkflow<A, B, SA, Running>

pub fn complete_b(self) -> ParallelWorkflow<A, B, SA, Completed>

Completes the task on Branch B.

Examples

use wasm4pm_compat::workflow::{ParallelWorkflow, Pending, Running, Completed};

struct TaskA;
struct TaskB;
let workflow: ParallelWorkflow<TaskA, TaskB, Pending, Pending> = ParallelWorkflow::split();
// Start both branches
let workflow = ParallelWorkflow {
    branch_a: workflow.branch_a.start(),
    branch_b: workflow.branch_b.start(),
};
// Complete branch B
let workflow: ParallelWorkflow<TaskA, TaskB, Running, Completed> = workflow.complete_b();

impl<A, B> ParallelWorkflow<A, B, Running, Running>

pub fn cancel_b_from_a(self) -> ParallelWorkflow<A, B, Completed, Canceled>

Fires a cancellation event from Branch A that targets Branch B. This transition consumes the active BranchToken<B, Running> and returns a BranchToken<B, Canceled> token. Because the running token is consumed and cannot be cloned, Branch B can never be completed.

Examples

use wasm4pm_compat::workflow::{ParallelWorkflow, Pending, Running, Completed, Canceled};

struct TaskA;
struct TaskB;
let workflow: ParallelWorkflow<TaskA, TaskB, Pending, Pending> = ParallelWorkflow::split();
// Start both branches
let workflow = ParallelWorkflow {
    branch_a: workflow.branch_a.start(),
    branch_b: workflow.branch_b.start(),
};
// Cancel Branch B from Branch A
let workflow: ParallelWorkflow<TaskA, TaskB, Completed, Canceled> = workflow.cancel_b_from_a();