Struct StateMachine 

pub struct StateMachine<S, E, C>
where
    S: State,
    E: Event,
    C: Context,
{
    pub(crate) id: String,
    pub(crate) transitions: HashMap<(S, E), Vec<Transition<S, E, C>>>,
    pub(crate) fail_callback: Option<FailCallback<S, E, C>>,
    pub(crate) history: Arc<Mutex<Vec<TransitionRecord<S, E>>>>,
    pub(crate) metrics: Arc<Mutex<StateMachineMetrics>>,
    pub(crate) state_actions: HashMap<S, StateActions<S, E, C>>,
    pub(crate) state_timeouts: HashMap<S, Duration>,
    pub(crate) timeout_transitions: HashMap<S, (S, E)>,
    pub(crate) async_actions: HashMap<(S, E), Box<dyn AsyncAction<S, E, C>>>,
}

The main state machine struct

Fields

id: String

transitions: HashMap<(S, E), Vec<Transition<S, E, C>>>

fail_callback: Option<FailCallback<S, E, C>>

history: Arc<Mutex<Vec<TransitionRecord<S, E>>>>

metrics: Arc<Mutex<StateMachineMetrics>>

state_actions: HashMap<S, StateActions<S, E, C>>

state_timeouts: HashMap<S, Duration>

timeout_transitions: HashMap<S, (S, E)>

async_actions: HashMap<(S, E), Box<dyn AsyncAction<S, E, C>>>

Implementations

impl<S, E, C> StateMachine<S, E, C>

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

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

Fire an event and perform state transition

Examples found in repository

examples/order_example.rs (line 74)

fn basic_example() {
    println!("=== Basic State Machine Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, ctx| {
            println!("Order {} payment initiated", ctx.order_id);
        });

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .perform(|_s, _e, ctx| {
            println!("Payment confirmed for order {}", ctx.order_id);
        });

    let state_machine = builder.id("BasicOrderMachine").build();

    let context = OrderContext {
        order_id: "ORD-001".to_string(),
        amount: 99.99,
        customer_id: "CUST-123".to_string(),
    };

    let result = state_machine.fire_event(OrderState::New, OrderEvent::Pay, context.clone());
    println!("Transition result: {:?}", result);
}

/// Example 2: With history tracking (requires 'history' feature)
#[cfg(feature = "history")]
fn history_example() {
    println!("\n=== History Tracking Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .perform(|_s, _e, _c| {});

    let state_machine = builder.id("HistoryOrderMachine").build();

    let context = OrderContext {
        order_id: "ORD-002".to_string(),
        amount: 149.99,
        customer_id: "CUST-456".to_string(),
    };

    // Execute multiple transitions
    let _ = state_machine.fire_event(OrderState::New, OrderEvent::Pay, context.clone());
    let _ = state_machine.fire_event(
        OrderState::PaymentPending,
        OrderEvent::ConfirmPayment,
        context.clone(),
    );
    let _ = state_machine.fire_event(OrderState::PaymentReceived, OrderEvent::Process, context);

    // Check history
    let history = state_machine.get_history();
    println!("Transition history:");
    for (i, record) in history.iter().enumerate() {
        println!(
            "  {}. {:?} -> {:?} via {:?} (success: {})",
            i + 1,
            record.from,
            record.to,
            record.event,
            record.success
        );
    }
}

/// Example 3: With entry/exit actions (requires 'extended' feature)
#[cfg(feature = "extended")]
fn extended_example() {
    println!("\n=== Extended State Machine Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    builder
        .with_entry_action(OrderState::Processing, |state, ctx| {
            println!(
                "ENTRY: Starting to process order {} in state {:?}",
                ctx.order_id, state
            );
        })
        .with_exit_action(OrderState::Processing, |state, ctx| {
            println!(
                "EXIT: Finished processing order {} from state {:?}",
                ctx.order_id, state
            );
        })
        .with_entry_action(OrderState::Shipped, |_state, ctx| {
            println!("ENTRY: Order {} has been shipped!", ctx.order_id);
        });

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Processing)
        .to(OrderState::Shipped)
        .on(OrderEvent::Ship)
        .perform(|_s, _e, _c| {});

    let state_machine = builder.id("ExtendedOrderMachine").build();

    let context = OrderContext {
        order_id: "ORD-003".to_string(),
        amount: 299.99,
        customer_id: "CUST-789".to_string(),
    };

    let _ = state_machine.fire_event(
        OrderState::PaymentReceived,
        OrderEvent::Process,
        context.clone(),
    );
    let _ = state_machine.fire_event(OrderState::Processing, OrderEvent::Ship, context);
}

/// Example 4: With metrics (requires 'metrics' feature)
#[cfg(feature = "metrics")]
fn metrics_example() {
    println!("\n=== Metrics Collection Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Add multiple transitions
    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .when(|_s, _e, ctx| ctx.amount > 0.0)
        .perform(|_s, _e, _c| {});

    builder
        .external_transitions()
        .from_among(vec![
            OrderState::New,
            OrderState::PaymentPending,
            OrderState::Processing,
        ])
        .to(OrderState::Cancelled)
        .on(OrderEvent::Cancel)
        .perform(|_s, _e, _c| {});

    let state_machine = builder.id("MetricsOrderMachine").build();

    // Simulate multiple orders
    for i in 0..10 {
        let context = OrderContext {
            order_id: format!("ORD-{:03}", i),
            amount: (i as f64) * 10.0,
            customer_id: format!("CUST-{:03}", i),
        };

        let _ = state_machine.fire_event(OrderState::New, OrderEvent::Pay, context.clone());

        if i % 3 == 0 {
            // Some orders get cancelled
            let _ =
                state_machine.fire_event(OrderState::PaymentPending, OrderEvent::Cancel, context);
        } else {
            // Others proceed normally
            let _ = state_machine.fire_event(
                OrderState::PaymentPending,
                OrderEvent::ConfirmPayment,
                context,
            );
        }
    }

    // Get and display metrics
    let metrics = state_machine.get_metrics();
    println!("State Machine Metrics:");
    println!("  Total transitions: {}", metrics.total_transitions);
    println!("  Successful: {}", metrics.successful_transitions);
    println!("  Failed: {}", metrics.failed_transitions);
    println!("  Success rate: {:.2}%", metrics.success_rate() * 100.0);

    if let Some(avg_time) = metrics.average_transition_time() {
        println!("  Average transition time: {:?}", avg_time);
    }

    println!("  State visit counts:");
    for (state, count) in &metrics.state_visit_counts {
        println!("    {}: {}", state, count);
    }
}

/// Example 5: With guard priorities (requires 'guards' feature)
#[cfg(feature = "guards")]
fn guards_example() {
    println!("\n=== Guard Priorities Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Multiple transitions with different priorities
    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .when(|_s, _e, ctx| ctx.amount < 100.0)
        .with_priority(10)
        .perform(|_s, _e, ctx| {
            println!(
                "Processing small order {} (amount: {})",
                ctx.order_id, ctx.amount
            );
        });

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .when(|_s, _e, ctx| ctx.amount >= 100.0 && ctx.amount < 1000.0)
        .with_priority(20)
        .perform(|_s, _e, ctx| {
            println!(
                "Processing medium order {} (amount: {})",
                ctx.order_id, ctx.amount
            );
        });

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .when(|_s, _e, ctx| ctx.amount >= 1000.0)
        .with_priority(30)
        .perform(|_s, _e, ctx| {
            println!(
                "Processing large order {} (amount: {}) - Priority handling!",
                ctx.order_id, ctx.amount
            );
        });

    let state_machine = builder.id("GuardsOrderMachine").build();

    // Test with different order amounts
    let contexts = vec![
        OrderContext {
            order_id: "ORD-SMALL".to_string(),
            amount: 50.0,
            customer_id: "C1".to_string(),
        },
        OrderContext {
            order_id: "ORD-MEDIUM".to_string(),
            amount: 500.0,
            customer_id: "C2".to_string(),
        },
        OrderContext {
            order_id: "ORD-LARGE".to_string(),
            amount: 5000.0,
            customer_id: "C3".to_string(),
        },
    ];

    for context in contexts {
        let _ = state_machine.fire_event(OrderState::PaymentReceived, OrderEvent::Process, context);
    }
}

/// Example 6: With visualization (requires 'visualization' feature)
#[cfg(feature = "visualization")]
fn visualization_example() {
    println!("\n=== Visualization Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Build a complete order flow
    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Processing)
        .to(OrderState::Shipped)
        .on(OrderEvent::Ship)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Shipped)
        .to(OrderState::Delivered)
        .on(OrderEvent::Deliver)
        .perform(|_s, _e, _c| {});

    builder
        .external_transitions()
        .from_among(vec![
            OrderState::New,
            OrderState::PaymentPending,
            OrderState::Processing,
        ])
        .to(OrderState::Cancelled)
        .on(OrderEvent::Cancel)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Cancelled)
        .to(OrderState::Refunded)
        .on(OrderEvent::Refund)
        .perform(|_s, _e, _c| {});

    let state_machine = builder.id("VisualOrderMachine").build();

    println!("DOT Format:");
    println!("{}", state_machine.to_dot());

    println!("\nPlantUML Format:");
    println!("{}", state_machine.to_plantuml());
}

/// Example 7: With parallel regions (requires 'parallel' feature)
#[cfg(feature = "parallel")]
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);
    }
}

/// Example 8: Complete example with multiple features
#[cfg(all(feature = "history", feature = "metrics", feature = "extended"))]
fn complete_example() {
    println!("\n=== Complete Example with Multiple Features ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Configure entry/exit actions
    builder
        .with_entry_action(OrderState::Processing, |_s, ctx| {
            println!("[ENTRY] Starting to process order {}", ctx.order_id);
        })
        .with_exit_action(OrderState::Processing, |_s, ctx| {
            println!("[EXIT] Finished processing order {}", ctx.order_id);
        });

    // Build transitions
    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, ctx| {
            println!("Payment initiated for ${}", ctx.amount);
        });

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .when(|_s, _e, ctx| ctx.amount > 0.0)
        .perform(|_s, _e, ctx| {
            println!("Payment confirmed: ${}", ctx.amount);
        });

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Processing)
        .to(OrderState::Shipped)
        .on(OrderEvent::Ship)
        .perform(|_s, _e, ctx| {
            println!("Order {} shipped", ctx.order_id);
        });

    builder.set_fail_callback(Arc::new(|state, event, ctx| {
        println!(
            "FAILED: Cannot handle {:?} in state {:?} for order {}",
            event, state, ctx.order_id
        );
    }));

    let state_machine = builder.id("CompleteOrderMachine").build();

    // Process an order through the complete flow
    let context = OrderContext {
        order_id: "ORD-COMPLETE".to_string(),
        amount: 999.99,
        customer_id: "CUST-VIP".to_string(),
    };

    println!("\nProcessing order through complete flow:");
    let states = [
        (OrderState::New, OrderEvent::Pay),
        (OrderState::PaymentPending, OrderEvent::ConfirmPayment),
        (OrderState::PaymentReceived, OrderEvent::Process),
        (OrderState::Processing, OrderEvent::Ship),
    ];

    for (state, event) in &states {
        let result = state_machine.fire_event(state.clone(), event.clone(), context.clone());
        println!("  {:?} + {:?} = {:?}", state, event, result);
    }

    // Try an invalid transition
    println!("\nTrying invalid transition:");
    let _ = state_machine.fire_event(OrderState::Shipped, OrderEvent::Pay, context);

    // Display collected data
    println!("\nHistory:");
    for record in state_machine.get_history() {
        println!(
            "  {:?} -> {:?} (success: {})",
            record.from, record.to, record.success
        );
    }

    println!("\nMetrics:");
    let metrics = state_machine.get_metrics();
    println!(
        "  Total: {}, Success: {}, Failed: {}",
        metrics.total_transitions, metrics.successful_transitions, metrics.failed_transitions
    );
}

examples/traffic_light_example.rs (line 312)

pub fn simulate_traffic_light_system() {
    println!("=== Traffic Light Control System Demo ===\n");

    let state_machine = build_traffic_light_system();

    let mut context = TrafficContext {
        intersection_id: "Main-St-First-Ave".to_string(),
        traffic_density: 0.5,
        pedestrian_waiting: false,
        emergency_active: false,
        time_in_state: std::time::Duration::from_secs(0),
    };

    // Normal cycle
    println!("--- Normal Traffic Cycle ---");
    let states_and_events = vec![
        (TrafficLightState::Green, TrafficLightEvent::Timer),
        (TrafficLightState::Yellow, TrafficLightEvent::Timer),
        (TrafficLightState::Red, TrafficLightEvent::Timer),
    ];

    for (state, event) in states_and_events {
        match state_machine.fire_event(state, event, context.clone()) {
            Ok(new_state) => {
                println!("  -> Now in {:?} state\n", new_state);
            }
            Err(e) => {
                eprintln!("  ERROR: {}\n", e);
            }
        }
        std::thread::sleep(std::time::Duration::from_millis(500));
    }

    // Emergency vehicle scenario
    println!("--- Emergency Vehicle Detected ---");
    context.emergency_active = true;

    match state_machine.fire_event(
        TrafficLightState::Green,
        TrafficLightEvent::EmergencyVehicleDetected,
        context.clone(),
    ) {
        Ok(new_state) => {
            println!("  -> Now in {:?} state\n", new_state);

            // Clear emergency after some time
            std::thread::sleep(std::time::Duration::from_secs(2));
            context.emergency_active = false;

            match state_machine.fire_event(
                new_state,
                TrafficLightEvent::EmergencyCleared,
                context.clone(),
            ) {
                Ok(cleared_state) => {
                    println!("  -> Emergency cleared, now in {:?} state\n", cleared_state);
                }
                Err(e) => eprintln!("  ERROR clearing emergency: {}\n", e),
            }
        }
        Err(e) => eprintln!("  ERROR handling emergency: {}\n", e),
    }

    // Feature-specific demonstrations
    #[cfg(feature = "history")]
    demonstrate_history(&state_machine);

    #[cfg(feature = "metrics")]
    demonstrate_metrics(&state_machine);

    #[cfg(feature = "visualization")]
    demonstrate_visualization(&state_machine);
}

pub fn verify(&self, from: S, event: E) -> bool

Verify if a transition is possible

pub fn id(&self) -> &str

Get the ID of the state machine

pub fn get_history(&self) -> Vec<TransitionRecord<S, E>>

Get transition history

Examples found in repository

examples/traffic_light_example.rs (line 369)

fn demonstrate_history(
    state_machine: &StateMachine<TrafficLightState, TrafficLightEvent, TrafficContext>,
) {
    println!("--- Transition History ---");
    let history = state_machine.get_history();
    for (i, record) in history.iter().enumerate() {
        println!(
            "  {}. {:?} -> {:?} via {:?} ({})",
            i + 1,
            record.from,
            record.to,
            record.event,
            if record.success { "✓" } else { "✗" }
        );
    }
    println!();
}

examples/order_example.rs (line 124)

fn history_example() {
    println!("\n=== History Tracking Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .perform(|_s, _e, _c| {});

    let state_machine = builder.id("HistoryOrderMachine").build();

    let context = OrderContext {
        order_id: "ORD-002".to_string(),
        amount: 149.99,
        customer_id: "CUST-456".to_string(),
    };

    // Execute multiple transitions
    let _ = state_machine.fire_event(OrderState::New, OrderEvent::Pay, context.clone());
    let _ = state_machine.fire_event(
        OrderState::PaymentPending,
        OrderEvent::ConfirmPayment,
        context.clone(),
    );
    let _ = state_machine.fire_event(OrderState::PaymentReceived, OrderEvent::Process, context);

    // Check history
    let history = state_machine.get_history();
    println!("Transition history:");
    for (i, record) in history.iter().enumerate() {
        println!(
            "  {}. {:?} -> {:?} via {:?} (success: {})",
            i + 1,
            record.from,
            record.to,
            record.event,
            record.success
        );
    }
}

/// Example 3: With entry/exit actions (requires 'extended' feature)
#[cfg(feature = "extended")]
fn extended_example() {
    println!("\n=== Extended State Machine Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    builder
        .with_entry_action(OrderState::Processing, |state, ctx| {
            println!(
                "ENTRY: Starting to process order {} in state {:?}",
                ctx.order_id, state
            );
        })
        .with_exit_action(OrderState::Processing, |state, ctx| {
            println!(
                "EXIT: Finished processing order {} from state {:?}",
                ctx.order_id, state
            );
        })
        .with_entry_action(OrderState::Shipped, |_state, ctx| {
            println!("ENTRY: Order {} has been shipped!", ctx.order_id);
        });

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Processing)
        .to(OrderState::Shipped)
        .on(OrderEvent::Ship)
        .perform(|_s, _e, _c| {});

    let state_machine = builder.id("ExtendedOrderMachine").build();

    let context = OrderContext {
        order_id: "ORD-003".to_string(),
        amount: 299.99,
        customer_id: "CUST-789".to_string(),
    };

    let _ = state_machine.fire_event(
        OrderState::PaymentReceived,
        OrderEvent::Process,
        context.clone(),
    );
    let _ = state_machine.fire_event(OrderState::Processing, OrderEvent::Ship, context);
}

/// Example 4: With metrics (requires 'metrics' feature)
#[cfg(feature = "metrics")]
fn metrics_example() {
    println!("\n=== Metrics Collection Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Add multiple transitions
    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .when(|_s, _e, ctx| ctx.amount > 0.0)
        .perform(|_s, _e, _c| {});

    builder
        .external_transitions()
        .from_among(vec![
            OrderState::New,
            OrderState::PaymentPending,
            OrderState::Processing,
        ])
        .to(OrderState::Cancelled)
        .on(OrderEvent::Cancel)
        .perform(|_s, _e, _c| {});

    let state_machine = builder.id("MetricsOrderMachine").build();

    // Simulate multiple orders
    for i in 0..10 {
        let context = OrderContext {
            order_id: format!("ORD-{:03}", i),
            amount: (i as f64) * 10.0,
            customer_id: format!("CUST-{:03}", i),
        };

        let _ = state_machine.fire_event(OrderState::New, OrderEvent::Pay, context.clone());

        if i % 3 == 0 {
            // Some orders get cancelled
            let _ =
                state_machine.fire_event(OrderState::PaymentPending, OrderEvent::Cancel, context);
        } else {
            // Others proceed normally
            let _ = state_machine.fire_event(
                OrderState::PaymentPending,
                OrderEvent::ConfirmPayment,
                context,
            );
        }
    }

    // Get and display metrics
    let metrics = state_machine.get_metrics();
    println!("State Machine Metrics:");
    println!("  Total transitions: {}", metrics.total_transitions);
    println!("  Successful: {}", metrics.successful_transitions);
    println!("  Failed: {}", metrics.failed_transitions);
    println!("  Success rate: {:.2}%", metrics.success_rate() * 100.0);

    if let Some(avg_time) = metrics.average_transition_time() {
        println!("  Average transition time: {:?}", avg_time);
    }

    println!("  State visit counts:");
    for (state, count) in &metrics.state_visit_counts {
        println!("    {}: {}", state, count);
    }
}

/// Example 5: With guard priorities (requires 'guards' feature)
#[cfg(feature = "guards")]
fn guards_example() {
    println!("\n=== Guard Priorities Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Multiple transitions with different priorities
    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .when(|_s, _e, ctx| ctx.amount < 100.0)
        .with_priority(10)
        .perform(|_s, _e, ctx| {
            println!(
                "Processing small order {} (amount: {})",
                ctx.order_id, ctx.amount
            );
        });

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .when(|_s, _e, ctx| ctx.amount >= 100.0 && ctx.amount < 1000.0)
        .with_priority(20)
        .perform(|_s, _e, ctx| {
            println!(
                "Processing medium order {} (amount: {})",
                ctx.order_id, ctx.amount
            );
        });

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .when(|_s, _e, ctx| ctx.amount >= 1000.0)
        .with_priority(30)
        .perform(|_s, _e, ctx| {
            println!(
                "Processing large order {} (amount: {}) - Priority handling!",
                ctx.order_id, ctx.amount
            );
        });

    let state_machine = builder.id("GuardsOrderMachine").build();

    // Test with different order amounts
    let contexts = vec![
        OrderContext {
            order_id: "ORD-SMALL".to_string(),
            amount: 50.0,
            customer_id: "C1".to_string(),
        },
        OrderContext {
            order_id: "ORD-MEDIUM".to_string(),
            amount: 500.0,
            customer_id: "C2".to_string(),
        },
        OrderContext {
            order_id: "ORD-LARGE".to_string(),
            amount: 5000.0,
            customer_id: "C3".to_string(),
        },
    ];

    for context in contexts {
        let _ = state_machine.fire_event(OrderState::PaymentReceived, OrderEvent::Process, context);
    }
}

/// Example 6: With visualization (requires 'visualization' feature)
#[cfg(feature = "visualization")]
fn visualization_example() {
    println!("\n=== Visualization Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Build a complete order flow
    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Processing)
        .to(OrderState::Shipped)
        .on(OrderEvent::Ship)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Shipped)
        .to(OrderState::Delivered)
        .on(OrderEvent::Deliver)
        .perform(|_s, _e, _c| {});

    builder
        .external_transitions()
        .from_among(vec![
            OrderState::New,
            OrderState::PaymentPending,
            OrderState::Processing,
        ])
        .to(OrderState::Cancelled)
        .on(OrderEvent::Cancel)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Cancelled)
        .to(OrderState::Refunded)
        .on(OrderEvent::Refund)
        .perform(|_s, _e, _c| {});

    let state_machine = builder.id("VisualOrderMachine").build();

    println!("DOT Format:");
    println!("{}", state_machine.to_dot());

    println!("\nPlantUML Format:");
    println!("{}", state_machine.to_plantuml());
}

/// Example 7: With parallel regions (requires 'parallel' feature)
#[cfg(feature = "parallel")]
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);
    }
}

/// Example 8: Complete example with multiple features
#[cfg(all(feature = "history", feature = "metrics", feature = "extended"))]
fn complete_example() {
    println!("\n=== Complete Example with Multiple Features ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Configure entry/exit actions
    builder
        .with_entry_action(OrderState::Processing, |_s, ctx| {
            println!("[ENTRY] Starting to process order {}", ctx.order_id);
        })
        .with_exit_action(OrderState::Processing, |_s, ctx| {
            println!("[EXIT] Finished processing order {}", ctx.order_id);
        });

    // Build transitions
    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, ctx| {
            println!("Payment initiated for ${}", ctx.amount);
        });

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .when(|_s, _e, ctx| ctx.amount > 0.0)
        .perform(|_s, _e, ctx| {
            println!("Payment confirmed: ${}", ctx.amount);
        });

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Processing)
        .to(OrderState::Shipped)
        .on(OrderEvent::Ship)
        .perform(|_s, _e, ctx| {
            println!("Order {} shipped", ctx.order_id);
        });

    builder.set_fail_callback(Arc::new(|state, event, ctx| {
        println!(
            "FAILED: Cannot handle {:?} in state {:?} for order {}",
            event, state, ctx.order_id
        );
    }));

    let state_machine = builder.id("CompleteOrderMachine").build();

    // Process an order through the complete flow
    let context = OrderContext {
        order_id: "ORD-COMPLETE".to_string(),
        amount: 999.99,
        customer_id: "CUST-VIP".to_string(),
    };

    println!("\nProcessing order through complete flow:");
    let states = [
        (OrderState::New, OrderEvent::Pay),
        (OrderState::PaymentPending, OrderEvent::ConfirmPayment),
        (OrderState::PaymentReceived, OrderEvent::Process),
        (OrderState::Processing, OrderEvent::Ship),
    ];

    for (state, event) in &states {
        let result = state_machine.fire_event(state.clone(), event.clone(), context.clone());
        println!("  {:?} + {:?} = {:?}", state, event, result);
    }

    // Try an invalid transition
    println!("\nTrying invalid transition:");
    let _ = state_machine.fire_event(OrderState::Shipped, OrderEvent::Pay, context);

    // Display collected data
    println!("\nHistory:");
    for record in state_machine.get_history() {
        println!(
            "  {:?} -> {:?} (success: {})",
            record.from, record.to, record.success
        );
    }

    println!("\nMetrics:");
    let metrics = state_machine.get_metrics();
    println!(
        "  Total: {}, Success: {}, Failed: {}",
        metrics.total_transitions, metrics.successful_transitions, metrics.failed_transitions
    );
}

pub fn clear_history(&self)

Clear transition history

pub fn get_metrics(&self) -> StateMachineMetrics

Get metrics

Examples found in repository

examples/traffic_light_example.rs (line 388)

fn demonstrate_metrics(
    state_machine: &StateMachine<TrafficLightState, TrafficLightEvent, TrafficContext>,
) {
    println!("--- Performance Metrics ---");
    let metrics = state_machine.get_metrics();
    println!("  Total transitions: {}", metrics.total_transitions);
    println!("  Success rate: {:.1}%", metrics.success_rate() * 100.0);
    if let Some(avg_time) = metrics.average_transition_time() {
        println!("  Average transition time: {:?}", avg_time);
    }
    println!("  State visits:");
    for (state, count) in &metrics.state_visit_counts {
        println!("    {}: {} times", state, count);
    }
    println!();
}

examples/order_example.rs (line 253)

fn metrics_example() {
    println!("\n=== Metrics Collection Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Add multiple transitions
    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .when(|_s, _e, ctx| ctx.amount > 0.0)
        .perform(|_s, _e, _c| {});

    builder
        .external_transitions()
        .from_among(vec![
            OrderState::New,
            OrderState::PaymentPending,
            OrderState::Processing,
        ])
        .to(OrderState::Cancelled)
        .on(OrderEvent::Cancel)
        .perform(|_s, _e, _c| {});

    let state_machine = builder.id("MetricsOrderMachine").build();

    // Simulate multiple orders
    for i in 0..10 {
        let context = OrderContext {
            order_id: format!("ORD-{:03}", i),
            amount: (i as f64) * 10.0,
            customer_id: format!("CUST-{:03}", i),
        };

        let _ = state_machine.fire_event(OrderState::New, OrderEvent::Pay, context.clone());

        if i % 3 == 0 {
            // Some orders get cancelled
            let _ =
                state_machine.fire_event(OrderState::PaymentPending, OrderEvent::Cancel, context);
        } else {
            // Others proceed normally
            let _ = state_machine.fire_event(
                OrderState::PaymentPending,
                OrderEvent::ConfirmPayment,
                context,
            );
        }
    }

    // Get and display metrics
    let metrics = state_machine.get_metrics();
    println!("State Machine Metrics:");
    println!("  Total transitions: {}", metrics.total_transitions);
    println!("  Successful: {}", metrics.successful_transitions);
    println!("  Failed: {}", metrics.failed_transitions);
    println!("  Success rate: {:.2}%", metrics.success_rate() * 100.0);

    if let Some(avg_time) = metrics.average_transition_time() {
        println!("  Average transition time: {:?}", avg_time);
    }

    println!("  State visit counts:");
    for (state, count) in &metrics.state_visit_counts {
        println!("    {}: {}", state, count);
    }
}

/// Example 5: With guard priorities (requires 'guards' feature)
#[cfg(feature = "guards")]
fn guards_example() {
    println!("\n=== Guard Priorities Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Multiple transitions with different priorities
    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .when(|_s, _e, ctx| ctx.amount < 100.0)
        .with_priority(10)
        .perform(|_s, _e, ctx| {
            println!(
                "Processing small order {} (amount: {})",
                ctx.order_id, ctx.amount
            );
        });

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .when(|_s, _e, ctx| ctx.amount >= 100.0 && ctx.amount < 1000.0)
        .with_priority(20)
        .perform(|_s, _e, ctx| {
            println!(
                "Processing medium order {} (amount: {})",
                ctx.order_id, ctx.amount
            );
        });

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .when(|_s, _e, ctx| ctx.amount >= 1000.0)
        .with_priority(30)
        .perform(|_s, _e, ctx| {
            println!(
                "Processing large order {} (amount: {}) - Priority handling!",
                ctx.order_id, ctx.amount
            );
        });

    let state_machine = builder.id("GuardsOrderMachine").build();

    // Test with different order amounts
    let contexts = vec![
        OrderContext {
            order_id: "ORD-SMALL".to_string(),
            amount: 50.0,
            customer_id: "C1".to_string(),
        },
        OrderContext {
            order_id: "ORD-MEDIUM".to_string(),
            amount: 500.0,
            customer_id: "C2".to_string(),
        },
        OrderContext {
            order_id: "ORD-LARGE".to_string(),
            amount: 5000.0,
            customer_id: "C3".to_string(),
        },
    ];

    for context in contexts {
        let _ = state_machine.fire_event(OrderState::PaymentReceived, OrderEvent::Process, context);
    }
}

/// Example 6: With visualization (requires 'visualization' feature)
#[cfg(feature = "visualization")]
fn visualization_example() {
    println!("\n=== Visualization Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Build a complete order flow
    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Processing)
        .to(OrderState::Shipped)
        .on(OrderEvent::Ship)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Shipped)
        .to(OrderState::Delivered)
        .on(OrderEvent::Deliver)
        .perform(|_s, _e, _c| {});

    builder
        .external_transitions()
        .from_among(vec![
            OrderState::New,
            OrderState::PaymentPending,
            OrderState::Processing,
        ])
        .to(OrderState::Cancelled)
        .on(OrderEvent::Cancel)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Cancelled)
        .to(OrderState::Refunded)
        .on(OrderEvent::Refund)
        .perform(|_s, _e, _c| {});

    let state_machine = builder.id("VisualOrderMachine").build();

    println!("DOT Format:");
    println!("{}", state_machine.to_dot());

    println!("\nPlantUML Format:");
    println!("{}", state_machine.to_plantuml());
}

/// Example 7: With parallel regions (requires 'parallel' feature)
#[cfg(feature = "parallel")]
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);
    }
}

/// Example 8: Complete example with multiple features
#[cfg(all(feature = "history", feature = "metrics", feature = "extended"))]
fn complete_example() {
    println!("\n=== Complete Example with Multiple Features ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Configure entry/exit actions
    builder
        .with_entry_action(OrderState::Processing, |_s, ctx| {
            println!("[ENTRY] Starting to process order {}", ctx.order_id);
        })
        .with_exit_action(OrderState::Processing, |_s, ctx| {
            println!("[EXIT] Finished processing order {}", ctx.order_id);
        });

    // Build transitions
    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, ctx| {
            println!("Payment initiated for ${}", ctx.amount);
        });

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .when(|_s, _e, ctx| ctx.amount > 0.0)
        .perform(|_s, _e, ctx| {
            println!("Payment confirmed: ${}", ctx.amount);
        });

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Processing)
        .to(OrderState::Shipped)
        .on(OrderEvent::Ship)
        .perform(|_s, _e, ctx| {
            println!("Order {} shipped", ctx.order_id);
        });

    builder.set_fail_callback(Arc::new(|state, event, ctx| {
        println!(
            "FAILED: Cannot handle {:?} in state {:?} for order {}",
            event, state, ctx.order_id
        );
    }));

    let state_machine = builder.id("CompleteOrderMachine").build();

    // Process an order through the complete flow
    let context = OrderContext {
        order_id: "ORD-COMPLETE".to_string(),
        amount: 999.99,
        customer_id: "CUST-VIP".to_string(),
    };

    println!("\nProcessing order through complete flow:");
    let states = [
        (OrderState::New, OrderEvent::Pay),
        (OrderState::PaymentPending, OrderEvent::ConfirmPayment),
        (OrderState::PaymentReceived, OrderEvent::Process),
        (OrderState::Processing, OrderEvent::Ship),
    ];

    for (state, event) in &states {
        let result = state_machine.fire_event(state.clone(), event.clone(), context.clone());
        println!("  {:?} + {:?} = {:?}", state, event, result);
    }

    // Try an invalid transition
    println!("\nTrying invalid transition:");
    let _ = state_machine.fire_event(OrderState::Shipped, OrderEvent::Pay, context);

    // Display collected data
    println!("\nHistory:");
    for record in state_machine.get_history() {
        println!(
            "  {:?} -> {:?} (success: {})",
            record.from, record.to, record.success
        );
    }

    println!("\nMetrics:");
    let metrics = state_machine.get_metrics();
    println!(
        "  Total: {}, Success: {}, Failed: {}",
        metrics.total_transitions, metrics.successful_transitions, metrics.failed_transitions
    );
}

pub fn add_entry_action<F>(&mut self, state: S, action: F)

where F: Fn(&S, &C) + Send + Sync + 'static,

Add entry action for a state

pub fn add_exit_action<F>(&mut self, state: S, action: F)

where F: Fn(&S, &C) + Send + Sync + 'static,

Add exit action for a state

pub fn set_state_timeout( &mut self, state: S, duration: Duration, target_state: S, timeout_event: E, )

Set timeout for a state

pub fn to_dot(&self) -> String

Export to DOT format

Examples found in repository

examples/traffic_light_example.rs (line 408)

fn demonstrate_visualization(
    state_machine: &StateMachine<TrafficLightState, TrafficLightEvent, TrafficContext>,
) {
    println!("--- State Machine Visualization ---");
    println!("Saving to 'traffic_light.dot' and 'traffic_light.puml'");

    let dot = state_machine.to_dot();
    let plantuml = state_machine.to_plantuml();

    // In a real application, you would write these to files
    if let Err(e) = std::fs::write("traffic_light.dot", dot) {
        eprintln!("Failed to write DOT file: {}", e);
    }

    if let Err(e) = std::fs::write("traffic_light.puml", plantuml) {
        eprintln!("Failed to write PlantUML file: {}", e);
    }

    println!("  ✓ Visualization files created\n");
}

examples/order_example.rs (line 410)

fn visualization_example() {
    println!("\n=== Visualization Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Build a complete order flow
    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Processing)
        .to(OrderState::Shipped)
        .on(OrderEvent::Ship)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Shipped)
        .to(OrderState::Delivered)
        .on(OrderEvent::Deliver)
        .perform(|_s, _e, _c| {});

    builder
        .external_transitions()
        .from_among(vec![
            OrderState::New,
            OrderState::PaymentPending,
            OrderState::Processing,
        ])
        .to(OrderState::Cancelled)
        .on(OrderEvent::Cancel)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Cancelled)
        .to(OrderState::Refunded)
        .on(OrderEvent::Refund)
        .perform(|_s, _e, _c| {});

    let state_machine = builder.id("VisualOrderMachine").build();

    println!("DOT Format:");
    println!("{}", state_machine.to_dot());

    println!("\nPlantUML Format:");
    println!("{}", state_machine.to_plantuml());
}

pub fn to_plantuml(&self) -> String

Export to PlantUML format

Examples found in repository

examples/traffic_light_example.rs (line 409)

fn demonstrate_visualization(
    state_machine: &StateMachine<TrafficLightState, TrafficLightEvent, TrafficContext>,
) {
    println!("--- State Machine Visualization ---");
    println!("Saving to 'traffic_light.dot' and 'traffic_light.puml'");

    let dot = state_machine.to_dot();
    let plantuml = state_machine.to_plantuml();

    // In a real application, you would write these to files
    if let Err(e) = std::fs::write("traffic_light.dot", dot) {
        eprintln!("Failed to write DOT file: {}", e);
    }

    if let Err(e) = std::fs::write("traffic_light.puml", plantuml) {
        eprintln!("Failed to write PlantUML file: {}", e);
    }

    println!("  ✓ Visualization files created\n");
}

examples/order_example.rs (line 413)

fn visualization_example() {
    println!("\n=== Visualization Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Build a complete order flow
    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentReceived)
        .to(OrderState::Processing)
        .on(OrderEvent::Process)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Processing)
        .to(OrderState::Shipped)
        .on(OrderEvent::Ship)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Shipped)
        .to(OrderState::Delivered)
        .on(OrderEvent::Deliver)
        .perform(|_s, _e, _c| {});

    builder
        .external_transitions()
        .from_among(vec![
            OrderState::New,
            OrderState::PaymentPending,
            OrderState::Processing,
        ])
        .to(OrderState::Cancelled)
        .on(OrderEvent::Cancel)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::Cancelled)
        .to(OrderState::Refunded)
        .on(OrderEvent::Refund)
        .perform(|_s, _e, _c| {});

    let state_machine = builder.id("VisualOrderMachine").build();

    println!("DOT Format:");
    println!("{}", state_machine.to_dot());

    println!("\nPlantUML Format:");
    println!("{}", state_machine.to_plantuml());
}

impl<S, E, C> StateMachine<S, E, C>

where S: State + Send + Sync, E: Event + Send + Sync, C: Context + Send + Sync,

pub async fn fire_event_async( &self, from: S, event: E, context: C, ) -> Result<S, TransitionError>

Fire an event asynchronously