Struct StateMachineBuilder 

pub struct StateMachineBuilder<S: States, E: Events, const NS: usize, const NE: usize> { /* private fields */ }

Builder for constructing and validating state machines.

The builder pattern ensures all transitions are defined before the state machine is created. Validation occurs at build time to catch configuration errors early.

Type Parameters

• S: The state type implementing States
• E: The event type implementing Events
• NS: The total number of states (const generic)
• NE: The total number of events (const generic)

Example

use tinystate::StateMachineBuilder;

let sm = StateMachineBuilder::<S, E, 2, 1>::new()
    .initial(S::A)
    .transition(S::A, E::X, S::B)
    .transition(S::B, E::X, S::A)
    .build()
    .unwrap();

Implementations

impl<S: States, E: Events, const NS: usize, const NE: usize> StateMachineBuilder<S, E, NS, NE>

pub fn new() -> Self

Creates a new state machine builder.

All transitions are initially undefined and must be configured before calling build.

Example

use tinystate::StateMachineBuilder;

let builder = StateMachineBuilder::<S, E, 1, 1>::new();

pub const fn initial(self, state: S) -> Self

Sets the initial state of the state machine.

This must be called before building the state machine.

Example

let builder = StateMachineBuilder::<S, E, 2, 1>::new()
    .initial(S::A);

pub fn transition(self, from: S, event: E, to: S) -> Self

Adds a single state transition.

Defines that when in from state and event occurs, transition to to state.

Example

let builder = StateMachineBuilder::<S, E, 2, 1>::new()
    .transition(S::A, E::X, S::B);

pub fn transitions_from(self, from: S, transitions: &[(E, S)]) -> Self

Adds multiple transitions from the same source state.

Convenient for defining all outgoing transitions from a state at once.

Example

let builder = StateMachineBuilder::<S, E, 3, 2>::new()
    .transitions_from(S::A, &[(E::X, S::B), (E::Y, S::C)]);

pub fn self_loop(self, state: S, event: E) -> Self

Adds a self-loop transition where a state transitions back to itself.

Example

let builder = StateMachineBuilder::<S, E, 1, 1>::new()
    .self_loop(S::A, E::X);

pub fn build(self) -> Result<StateMachine<S, E, NS, NE>, ValidationError<S, E>>

Builds and validates the state machine.

Returns an error if:

• The initial state is not set
• Any transition is undefined
• State or event indices are invalid

Errors

Returns a ValidationError if the state machine configuration is invalid.

Example

let result = StateMachineBuilder::<S, E, 2, 1>::new()
    .initial(S::A)
    .transition(S::A, E::X, S::B)
    .transition(S::B, E::X, S::A)
    .build();

assert!(result.is_ok());

Trait Implementations

impl<S: States, E: Events, const NS: usize, const NE: usize> Default for StateMachineBuilder<S, E, NS, NE>

fn default() -> Self

Returns the “default value” for a type.