Struct ParallelStateMachine 

pub struct ParallelStateMachine<S, E, C>
where
    S: State,
    E: Event,
    C: Context,
{
    pub(crate) regions: Vec<StateMachine<S, E, C>>,
}

Fields

regions: Vec<StateMachine<S, E, C>>

Implementations

impl<S, E, C> ParallelStateMachine<S, E, C>

where S: State, E: Event, C: Context,

pub fn new() -> Self

Examples found in repository

examples/order_example.rs (line 448)

fn parallel_example() {
    println!("\n=== Parallel Regions Example ===");

    // Order processing region
    let mut order_builder =
        StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();
    order_builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .perform(|_s, _e, ctx| {
            println!("Order region: Processing order {}", ctx.order_id);
        });

    // Payment processing region (using same states/events for simplicity)
    let mut payment_builder =
        StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();
    payment_builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .perform(|_s, _e, ctx| {
            println!(
                "Payment region: Payment confirmed for order {}",
                ctx.order_id
            );
        });

    let mut parallel_machine = ParallelStateMachine::new();
    parallel_machine.add_region(order_builder.id("OrderRegion").build());
    parallel_machine.add_region(payment_builder.id("PaymentRegion").build());

    let context = OrderContext {
        order_id: "ORD-PARALLEL".to_string(),
        amount: 199.99,
        customer_id: "CUST-P1".to_string(),
    };

    // Fire events in parallel regions
    println!("Firing Process event in parallel regions:");
    let results = parallel_machine.fire_event(
        vec![OrderState::New, OrderState::PaymentPending],
        OrderEvent::Process,
        context.clone(),
    );

    for (i, result) in results.iter().enumerate() {
        println!("  Region {}: {:?}", i, result);
    }

    println!("Firing ConfirmPayment event in parallel regions:");
    let results = parallel_machine.fire_event(
        vec![OrderState::Processing, OrderState::PaymentPending],
        OrderEvent::ConfirmPayment,
        context,
    );

    for (i, result) in results.iter().enumerate() {
        println!("  Region {}: {:?}", i, result);
    }
}

pub fn add_region(&mut self, machine: StateMachine<S, E, C>)

Examples found in repository

examples/order_example.rs (line 449)

fn parallel_example() {
    println!("\n=== Parallel Regions Example ===");

    // Order processing region
    let mut order_builder =
        StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();
    order_builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .perform(|_s, _e, ctx| {
            println!("Order region: Processing order {}", ctx.order_id);
        });

    // Payment processing region (using same states/events for simplicity)
    let mut payment_builder =
        StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();
    payment_builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .perform(|_s, _e, ctx| {
            println!(
                "Payment region: Payment confirmed for order {}",
                ctx.order_id
            );
        });

    let mut parallel_machine = ParallelStateMachine::new();
    parallel_machine.add_region(order_builder.id("OrderRegion").build());
    parallel_machine.add_region(payment_builder.id("PaymentRegion").build());

    let context = OrderContext {
        order_id: "ORD-PARALLEL".to_string(),
        amount: 199.99,
        customer_id: "CUST-P1".to_string(),
    };

    // Fire events in parallel regions
    println!("Firing Process event in parallel regions:");
    let results = parallel_machine.fire_event(
        vec![OrderState::New, OrderState::PaymentPending],
        OrderEvent::Process,
        context.clone(),
    );

    for (i, result) in results.iter().enumerate() {
        println!("  Region {}: {:?}", i, result);
    }

    println!("Firing ConfirmPayment event in parallel regions:");
    let results = parallel_machine.fire_event(
        vec![OrderState::Processing, OrderState::PaymentPending],
        OrderEvent::ConfirmPayment,
        context,
    );

    for (i, result) in results.iter().enumerate() {
        println!("  Region {}: {:?}", i, result);
    }
}

pub fn fire_event( &self, states: Vec<S>, event: E, context: C, ) -> Vec<Result<S, TransitionError>>

Examples found in repository

examples/order_example.rs (lines 460-464)

fn parallel_example() {
    println!("\n=== Parallel Regions Example ===");

    // Order processing region
    let mut order_builder =
        StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();
    order_builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .perform(|_s, _e, ctx| {
            println!("Order region: Processing order {}", ctx.order_id);
        });

    // Payment processing region (using same states/events for simplicity)
    let mut payment_builder =
        StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();
    payment_builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .perform(|_s, _e, ctx| {
            println!(
                "Payment region: Payment confirmed for order {}",
                ctx.order_id
            );
        });

    let mut parallel_machine = ParallelStateMachine::new();
    parallel_machine.add_region(order_builder.id("OrderRegion").build());
    parallel_machine.add_region(payment_builder.id("PaymentRegion").build());

    let context = OrderContext {
        order_id: "ORD-PARALLEL".to_string(),
        amount: 199.99,
        customer_id: "CUST-P1".to_string(),
    };

    // Fire events in parallel regions
    println!("Firing Process event in parallel regions:");
    let results = parallel_machine.fire_event(
        vec![OrderState::New, OrderState::PaymentPending],
        OrderEvent::Process,
        context.clone(),
    );

    for (i, result) in results.iter().enumerate() {
        println!("  Region {}: {:?}", i, result);
    }

    println!("Firing ConfirmPayment event in parallel regions:");
    let results = parallel_machine.fire_event(
        vec![OrderState::Processing, OrderState::PaymentPending],
        OrderEvent::ConfirmPayment,
        context,
    );

    for (i, result) in results.iter().enumerate() {
        println!("  Region {}: {:?}", i, result);
    }
}

pub fn get_region(&self, index: usize) -> Option<&StateMachine<S, E, C>>

pub fn region_count(&self) -> usize