fsm

package module
v0.0.0-...-88244d5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 27, 2025 License: MIT Imports: 4 Imported by: 0

README

FSM-Go: A Lightweight Finite State Machine for Go

Go Reference Go Report Card

FSM-Go is a lightweight, high-performance, stateless finite state machine implementation in Go, inspired by Alibaba's COLA state machine component.

中文文档

✨ Features

  • 🪶 Lightweight - Minimal, stateless design for high performance
  • 🔒 Type-safe - Built with Go generics for compile-time type checking
  • 🔄 Fluent API - Intuitive builder pattern for defining state machines
  • 🔀 Versatile Transitions - Support for external, internal, and parallel transitions
  • 🧪 Conditional Logic - Flexible conditions to control when transitions occur
  • 🎬 Action Execution - Custom actions that execute during transitions
  • 🔄 Thread-safe - Designed for concurrent use in multi-threaded environments
  • 📊 Visualization - Built-in support for generating state machine diagrams

📦 Installation

go get github.com/lingcoder/fsm-go

🚀 Usage

package main

import (
	"fmt"
	"log"

	"github.com/lingcoder/fsm-go"
)

// Define states
type OrderState string

const (
	OrderCreated   OrderState = "CREATED"
	OrderPaid      OrderState = "PAID"
	OrderShipped   OrderState = "SHIPPED"
	OrderDelivered OrderState = "DELIVERED"
	OrderCancelled OrderState = "CANCELLED"
)

// Define events
type OrderEvent string

const (
	EventPay     OrderEvent = "PAY"
	EventShip    OrderEvent = "SHIP"
	EventDeliver OrderEvent = "DELIVER"
	EventCancel  OrderEvent = "CANCEL"
)

// Define payload
type OrderPayload struct {
	OrderID string
	Amount  float64
}

func main() {
	// Create a builder
	builder := fsm.NewStateMachineBuilder[OrderState, OrderEvent, OrderPayload]()

	// Define the state machine
	builder.ExternalTransition().
		From(OrderCreated).
		To(OrderPaid).
		On(EventPay).
		WhenFunc(func(payload OrderPayload) bool {
			// Check if amount is valid
			return payload.Amount > 0
		}).
		PerformFunc(func(from, to OrderState, event OrderEvent, payload OrderPayload) error {
			fmt.Printf("Order %s transitioning from %s to %s on event %s\n",
				payload.OrderID, from, to, event)
			return nil
		})

	builder.ExternalTransition().
		From(OrderPaid).
		To(OrderShipped).
		On(EventShip).
		WhenFunc(func(payload OrderPayload) bool {
			return true
		}).
		PerformFunc(func(from, to OrderState, event OrderEvent, payload OrderPayload) error {
			fmt.Printf("Order %s is being shipped\n", payload.OrderID)
			return nil
		})

	// Define multiple source transitions
	builder.ExternalTransitions().
		FromAmong(OrderCreated, OrderPaid, OrderShipped).
		To(OrderCancelled).
		On(EventCancel).
		WhenFunc(func(payload OrderPayload) bool {
			return true
		}).
		PerformFunc(func(from, to OrderState, event OrderEvent, payload OrderPayload) error {
			fmt.Printf("Order %s cancelled from %s state\n", payload.OrderID, from)
			return nil
		})

	// Build the state machine
	stateMachine, err := builder.Build("OrderStateMachine")
	if err != nil {
		log.Fatalf("Failed to build state machine: %v", err)
	}

	// Create payload
	payload := OrderPayload{
		OrderID: "ORD-20250425-001",
		Amount:  100.0,
	}

	// Transition from CREATED to PAID
	newState, err := stateMachine.FireEvent(OrderCreated, EventPay, payload)
	if err != nil {
		log.Fatalf("Transition failed: %v", err)
	}

	fmt.Printf("New state: %v\n", newState)
}

🧩 Core Concepts

Concept Description
State Represents a specific state in your business process
Event Triggers state transitions
Transition Defines how states change in response to events
Condition Logic that determines if a transition should occur
Action Logic executed when a transition occurs
StateMachine The core component that manages states and transitions
Types of Transitions
  • External Transition: Transition between different states
  • Internal Transition: Actions within the same state
  • Parallel Transition: Transition to multiple states simultaneously

📚 Examples

Check the examples directory for more detailed examples:

  • examples/order: Order processing workflow
  • examples/workflow: Approval workflow
  • examples/game: Game state management

⚡ Performance

FSM-Go is designed for high performance:

  • Stateless design minimizes memory usage
  • Efficient transition lookup
  • Thread-safe for concurrent use
  • Benchmarks included in the test suite

📊 Visualization

FSM-Go provides a unified way to visualize your state machine with different formats:

// Default format (PlantUML)
plantUML := stateMachine.GenerateDiagram()
fmt.Println(plantUML)

// Generate specific format
table := stateMachine.GenerateDiagram(fsm.MarkdownTable)     // Markdown table format
fmt.Println(table)

flow := stateMachine.GenerateDiagram(fsm.MarkdownFlowchart)  // Markdown flowchart format
fmt.Println(flow)

// Generate multiple formats separately
diagrams := stateMachine.GenerateDiagram(fsm.PlantUML, fsm.MarkdownTable, fsm.MarkdownFlowchart, fsm.MarkdownStateDiagram)
fmt.Println(diagrams)

📄 License

MIT © LingCoder

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrStateMachineNotFound     = errors.New("state machine not found")
	ErrStateMachineAlreadyExist = errors.New("state machine already exists")
	ErrStateNotFound            = errors.New("state not found")
	ErrTransitionNotFound       = errors.New("no transition found")
	ErrConditionNotMet          = errors.New("transition conditions not met")
	ErrActionExecutionFailed    = errors.New("action execution failed")
	ErrStateMachineNotReady     = errors.New("state machine is not ready yet")
	ErrInternalTransition       = errors.New("internal transition source and target states must be the same")
)

Error constants - standard error definitions

Functions

func ListStateMachines 

func ListStateMachines() []string

ListStateMachines returns a list of all registered state machine IDs Returns: 

Slice of state machine IDs

func RegisterStateMachine 

func RegisterStateMachine[S comparable, E comparable, P any](machineId string, stateMachine StateMachine[S, E, P]) error

RegisterStateMachine adds a state machine to the registry Parameters: 

machineId: Unique identifier for the state machine
stateMachine: State machine instance to register

Returns: 

Error if a state machine with the same ID already exists

func RemoveStateMachine 

func RemoveStateMachine(machineId string) bool

RemoveStateMachine removes a state machine from the registry Parameters: 

machineId: Unique identifier for the state machine to remove

Returns: 

True if the state machine was found and removed, false otherwise

Types

type Action 

type Action[S comparable, E comparable, P any] interface {
	// Execute runs the action during a state transition
	Execute(from, to S, event E, payload P) error
}

Action is an interface for transition actions

type ActionFunc 

type ActionFunc[S comparable, E comparable, P any] func(from, to S, event E, payload P) error

ActionFunc is a function type that implements Action interface

func (ActionFunc[S, E, P]) Execute 

func (f ActionFunc[S, E, P]) Execute(from, to S, event E, payload P) error

Execute implements Action interface

type Condition 

type Condition[P any] interface {
	// IsSatisfied returns true if the condition is met
	IsSatisfied(payload P) bool
}

Condition is an interface for transition conditions

type ConditionFunc 

type ConditionFunc[P any] func(payload P) bool

ConditionFunc is a function type that implements Condition interface

func (ConditionFunc[P]) IsSatisfied 

func (f ConditionFunc[P]) IsSatisfied(payload P) bool

IsSatisfied implements Condition interface

type DiagramFormat 

type DiagramFormat int

DiagramFormat defines the supported diagram formats 

const (
	// PlantUML format for UML diagrams
	PlantUML DiagramFormat = iota
	// MarkdownTable format for tabular representation
	MarkdownTable
	// MarkdownFlowchart format for flowcharts
	MarkdownFlowchart
	// MarkdownStateDiagram format for Mermaid state diagrams
	MarkdownStateDiagram
)

type ExternalParallelTransitionBuilder 

type ExternalParallelTransitionBuilder[S comparable, E comparable, P any] struct {
	// contains filtered or unexported fields
}

ExternalParallelTransitionBuilder builds external parallel transitions

func (*ExternalParallelTransitionBuilder[S, E, P]) From 

func (b *ExternalParallelTransitionBuilder[S, E, P]) From(state S) ParallelFromInterface[S, E, P]

From specifies the source state Parameters: 

state: Source state

Returns: 

The parallel from builder for method chaining

type ExternalParallelTransitionBuilderInterface 

type ExternalParallelTransitionBuilderInterface[S comparable, E comparable, P any] interface {
	// From specifies the source state
	From(state S) ParallelFromInterface[S, E, P]
}

ExternalParallelTransitionBuilderInterface is the interface for building external parallel transitions

type ExternalTransitionBuilderInterface 

type ExternalTransitionBuilderInterface[S comparable, E comparable, P any] interface {
	// From specifies the source state
	From(state S) FromInterface[S, E, P]
}

ExternalTransitionBuilderInterface is the interface for building external transitions

type ExternalTransitionsBuilder 

type ExternalTransitionsBuilder[S comparable, E comparable, P any] struct {
	// contains filtered or unexported fields
}

ExternalTransitionsBuilder builds external transitions from multiple source states to a single target state

func (*ExternalTransitionsBuilder[S, E, P]) FromAmong 

func (b *ExternalTransitionsBuilder[S, E, P]) FromAmong(states ...S) FromInterface[S, E, P]

FromAmong specifies multiple source states Parameters: 

states: Multiple source states

Returns: 

The from builder for method chaining

type ExternalTransitionsBuilderInterface 

type ExternalTransitionsBuilderInterface[S comparable, E comparable, P any] interface {
	// FromAmong specifies multiple source states
	FromAmong(states ...S) FromInterface[S, E, P]
}

ExternalTransitionsBuilderInterface is the interface for building multiple external transitions

type FromBuilder 

type FromBuilder[S comparable, E comparable, P any, Next any] struct {
	// contains filtered or unexported fields
}

FromBuilder builds the "from" part of multiple transitions

func (*FromBuilder[S, E, P, Next]) On 

func (b *FromBuilder[S, E, P, Next]) On(event E) OnInterface[S, E, P]

On specifies the triggering event Parameters: 

event: The event that triggers these transitions

Returns: 

The from builder for method chaining

func (*FromBuilder[S, E, P, Next]) Perform 

func (b *FromBuilder[S, E, P, Next]) Perform(action Action[S, E, P])

Perform specifies the action to execute during all transitions Parameters: 

action: The action to execute when the transitions occur

func (*FromBuilder[S, E, P, Next]) PerformFunc 

func (b *FromBuilder[S, E, P, Next]) PerformFunc(actionFunc func(from, to S, event E, payload P) error)

PerformFunc specifies a function as the action to execute during all transitions Parameters: 

actionFunc: The function to execute when the transitions occur

func (*FromBuilder[S, E, P, Next]) To 

func (b *FromBuilder[S, E, P, Next]) To(state S) ToInterface[S, E, P]

To specifies the target state Parameters: 

state: Target state

Returns: 

The from builder for method chaining

func (*FromBuilder[S, E, P, Next]) When 

func (b *FromBuilder[S, E, P, Next]) When(condition Condition[P]) WhenInterface[S, E, P]

When specifies the condition for all transitions Parameters: 

condition: The condition that must be satisfied for the transitions to occur

Returns: 

The from builder for method chaining

func (*FromBuilder[S, E, P, Next]) WhenFunc 

func (b *FromBuilder[S, E, P, Next]) WhenFunc(conditionFunc func(payload P) bool) WhenInterface[S, E, P]

WhenFunc specifies a function as the condition for all transitions Parameters: 

conditionFunc: The function that must return true for the transitions to occur

Returns: 

The from builder for method chaining

type FromInterface 

type FromInterface[S comparable, E comparable, P any] interface {
	// To specifies the target state
	To(state S) ToInterface[S, E, P]
}

FromInterface is the interface for specifying the source state of a transition

type FromStep 

type FromStep interface{}

FromStep Step marker interfaces to enforce the correct order of method calls

type InternalTransitionBuilder 

type InternalTransitionBuilder[S comparable, E comparable, P any] struct {
	// contains filtered or unexported fields
}

InternalTransitionBuilder builds internal transitions

func (*InternalTransitionBuilder[S, E, P]) Within 

func (b *InternalTransitionBuilder[S, E, P]) Within(state S) ToInterface[S, E, P]

Within specifies the state where the internal transition occurs Parameters: 

state: The state where the internal transition occurs

Returns: 

The internal transition builder for method chaining

type InternalTransitionBuilderInterface 

type InternalTransitionBuilderInterface[S comparable, E comparable, P any] interface {
	// Within specifies the state where the internal transition occurs
	Within(state S) ToInterface[S, E, P]
}

InternalTransitionBuilderInterface is the interface for building internal transitions

type OnInterface 

type OnInterface[S comparable, E comparable, P any] interface {
	// When specifies the condition for the transition
	When(condition Condition[P]) WhenInterface[S, E, P]

	// WhenFunc specifies a function as the condition for the transition
	WhenFunc(conditionFunc func(payload P) bool) WhenInterface[S, E, P]
}

OnInterface is the interface for specifying the triggering event of a transition

type OnStep 

type OnStep interface{}

type OnTransitionBuilder 

type OnTransitionBuilder[S comparable, E comparable, P any, Next any] struct {
	// contains filtered or unexported fields
}

OnTransitionBuilder builds the "on" part of an internal transition

func (*OnTransitionBuilder[S, E, P, Next]) On 

func (b *OnTransitionBuilder[S, E, P, Next]) On(event E) OnInterface[S, E, P]

On specifies the triggering event Parameters: 

event: The event that triggers this transition

Returns: 

The on transition builder for method chaining

func (*OnTransitionBuilder[S, E, P, Next]) Perform 

func (b *OnTransitionBuilder[S, E, P, Next]) Perform(action Action[S, E, P])

Perform specifies the action to execute during the transition Parameters: 

action: The action to execute when the transition occurs

func (*OnTransitionBuilder[S, E, P, Next]) PerformFunc 

func (b *OnTransitionBuilder[S, E, P, Next]) PerformFunc(actionFunc func(from, to S, event E, payload P) error)

PerformFunc specifies a function as the action to execute during the transition Parameters: 

actionFunc: The function to execute when the transition occurs

func (*OnTransitionBuilder[S, E, P, Next]) To 

func (b *OnTransitionBuilder[S, E, P, Next]) To(state S) ToInterface[S, E, P]

To specifies the target state Parameters: 

state: Target state

Returns: 

The on transition builder for method chaining

func (*OnTransitionBuilder[S, E, P, Next]) When 

func (b *OnTransitionBuilder[S, E, P, Next]) When(condition Condition[P]) WhenInterface[S, E, P]

When specifies the condition for the transition Parameters: 

condition: The condition that must be satisfied for the transition to occur

Returns: 

The on transition builder for method chaining

func (*OnTransitionBuilder[S, E, P, Next]) WhenFunc 

func (b *OnTransitionBuilder[S, E, P, Next]) WhenFunc(conditionFunc func(payload P) bool) WhenInterface[S, E, P]

WhenFunc specifies a function as the condition for the transition Parameters: 

conditionFunc: The function that must return true for the transition to occur

Returns: 

The on transition builder for method chaining

type ParallelFromBuilder 

type ParallelFromBuilder[S comparable, E comparable, P any, Next any] struct {
	// contains filtered or unexported fields
}

ParallelFromBuilder builds the "from" part of a parallel transition

func (*ParallelFromBuilder[S, E, P, Next]) On 

func (b *ParallelFromBuilder[S, E, P, Next]) On(event E) OnInterface[S, E, P]

On specifies the triggering event Parameters: 

event: The event that triggers these transitions

Returns: 

The parallel from builder for method chaining

func (*ParallelFromBuilder[S, E, P, Next]) Perform 

func (b *ParallelFromBuilder[S, E, P, Next]) Perform(action Action[S, E, P])

Perform specifies the action to execute during all transitions Parameters: 

action: The action to execute when the transitions occur

func (*ParallelFromBuilder[S, E, P, Next]) PerformFunc 

func (b *ParallelFromBuilder[S, E, P, Next]) PerformFunc(actionFunc func(from, to S, event E, payload P) error)

PerformFunc specifies a function as the action to execute during all transitions Parameters: 

actionFunc: The function to execute when the transitions occur

func (*ParallelFromBuilder[S, E, P, Next]) ToAmong 

func (b *ParallelFromBuilder[S, E, P, Next]) ToAmong(states ...S) ToInterface[S, E, P]

ToAmong specifies multiple target states Parameters: 

states: Multiple target states

Returns: 

The parallel from builder for method chaining

func (*ParallelFromBuilder[S, E, P, Next]) When 

func (b *ParallelFromBuilder[S, E, P, Next]) When(condition Condition[P]) WhenInterface[S, E, P]

When specifies the condition for all transitions Parameters: 

condition: The condition that must be satisfied for the transitions to occur

Returns: 

The parallel from builder for method chaining

func (*ParallelFromBuilder[S, E, P, Next]) WhenFunc 

func (b *ParallelFromBuilder[S, E, P, Next]) WhenFunc(conditionFunc func(payload P) bool) WhenInterface[S, E, P]

WhenFunc specifies a function as the condition for all transitions Parameters: 

conditionFunc: The function that must return true for the transitions to occur

Returns: 

The parallel from builder for method chaining

type ParallelFromInterface 

type ParallelFromInterface[S comparable, E comparable, P any] interface {
	// ToAmong specifies multiple target states
	ToAmong(states ...S) ToInterface[S, E, P]
}

ParallelFromInterface is the interface for specifying the source state of a parallel transition

type PerformStep 

type PerformStep interface{}

type State 

type State[S comparable, E comparable, P any] struct {
	// contains filtered or unexported fields
}

State represents a state in the state machine

func NewState 

func NewState[S comparable, E comparable, P any](id S) *State[S, E, P]

NewState creates a new state

func (*State[S, E, P]) AddParallelTransitions 

func (s *State[S, E, P]) AddParallelTransitions(event E, targets []*State[S, E, P], transType TransitionType) []*Transition[S, E, P]

AddParallelTransitions adds multiple transitions for the same event to different target states

func (*State[S, E, P]) AddTransition 

func (s *State[S, E, P]) AddTransition(event E, target *State[S, E, P], transType TransitionType) *Transition[S, E, P]

AddTransition adds a transition to this state

func (*State[S, E, P]) GetEventTransitions 

func (s *State[S, E, P]) GetEventTransitions(event E) []*Transition[S, E, P]

GetEventTransitions returns all transitions for a given event

func (*State[S, E, P]) GetID 

func (s *State[S, E, P]) GetID() S

GetID returns the state ID

type StateMachine 

type StateMachine[S comparable, E comparable, P any] interface {
	// FireEvent triggers a state transition based on the current state and event
	// Returns the new state and any error that occurred
	FireEvent(sourceState S, event E, payload P) (S, error)

	// FireParallelEvent triggers parallel state transitions based on the current state and event
	// Returns a slice of new states and any error that occurred
	FireParallelEvent(sourceState S, event E, payload P) ([]S, error)

	// Verify checks if there is a valid transition for the given state and event
	// Returns true if a transition exists, false otherwise
	Verify(sourceState S, event E) bool

	// ShowStateMachine returns a string representation of the state machine
	ShowStateMachine() string

	// GenerateDiagram returns a diagram of the state machine in the specified formats
	// If formats is nil or empty, defaults to PlantUML
	// If multiple formats are provided, returns all requested formats concatenated
	GenerateDiagram(formats ...DiagramFormat) string
}

StateMachine is a generic state machine interface S: State type, must be comparable (e.g., string, int) E: Event type, must be comparable P: Payload type, can be any type, used to pass data during state transitions

func GetStateMachine 

func GetStateMachine[S comparable, E comparable, P any](machineId string) (StateMachine[S, E, P], error)

GetStateMachine retrieves a state machine by ID Parameters: 

machineId: Unique identifier for the state machine to retrieve

Returns: 

The state machine instance and error if not found or type mismatch

type StateMachineBuilder 

type StateMachineBuilder[S comparable, E comparable, P any] struct {
	// contains filtered or unexported fields
}

StateMachineBuilder builds state machines with a fluent API

func NewStateMachineBuilder 

func NewStateMachineBuilder[S comparable, E comparable, P any]() *StateMachineBuilder[S, E, P]

NewStateMachineBuilder creates a new builder Returns: 

A new state machine builder instance

func (*StateMachineBuilder[S, E, P]) Build 

func (b *StateMachineBuilder[S, E, P]) Build(machineId string) (StateMachine[S, E, P], error)

Build finalizes the state machine with the given ID Parameters: 

machineId: Unique identifier for the state machine

Returns: 

The built state machine and possible error

func (*StateMachineBuilder[S, E, P]) ExternalParallelTransition 

func (b *StateMachineBuilder[S, E, P]) ExternalParallelTransition() ExternalParallelTransitionBuilderInterface[S, E, P]

ExternalParallelTransition starts defining an external parallel transition Returns: 

A external parallel transition builder for configuring the parallel transition

func (*StateMachineBuilder[S, E, P]) ExternalTransition 

func (b *StateMachineBuilder[S, E, P]) ExternalTransition() ExternalTransitionBuilderInterface[S, E, P]

ExternalTransition starts defining an external transition Returns: 

A transition builder for configuring the external transition

func (*StateMachineBuilder[S, E, P]) ExternalTransitions 

func (b *StateMachineBuilder[S, E, P]) ExternalTransitions() ExternalTransitionsBuilderInterface[S, E, P]

ExternalTransitions starts defining multiple external transitions from different source states to the same target state Returns: 

A external transitions builder for configuring the transitions

func (*StateMachineBuilder[S, E, P]) InternalTransition 

func (b *StateMachineBuilder[S, E, P]) InternalTransition() InternalTransitionBuilderInterface[S, E, P]

InternalTransition starts defining an internal transition Returns: 

A internal transition builder for configuring the internal transition

type StateMachineImpl 

type StateMachineImpl[S comparable, E comparable, P any] struct {
	// contains filtered or unexported fields
}

StateMachineImpl implements the StateMachine interface

func (*StateMachineImpl[S, E, P]) FireEvent 

func (sm *StateMachineImpl[S, E, P]) FireEvent(sourceStateId S, event E, payload P) (S, error)

FireEvent triggers a state transition based on the current state and event

func (*StateMachineImpl[S, E, P]) FireParallelEvent 

func (sm *StateMachineImpl[S, E, P]) FireParallelEvent(sourceStateId S, event E, payload P) ([]S, error)

FireParallelEvent triggers parallel state transitions based on the current state and event

func (*StateMachineImpl[S, E, P]) GenerateDiagram 

func (sm *StateMachineImpl[S, E, P]) GenerateDiagram(formats ...DiagramFormat) string

GenerateDiagram returns a diagram of the state machine in the specified formats If formats is nil or empty, defaults to PlantUML If multiple formats are provided, returns all requested formats concatenated

func (*StateMachineImpl[S, E, P]) GetState 

func (sm *StateMachineImpl[S, E, P]) GetState(stateId S) *State[S, E, P]

GetState returns a state by ID, creating it if it doesn't exist

func (*StateMachineImpl[S, E, P]) SetReady 

func (sm *StateMachineImpl[S, E, P]) SetReady(ready bool)

SetReady marks the state machine as ready

func (*StateMachineImpl[S, E, P]) ShowStateMachine 

func (sm *StateMachineImpl[S, E, P]) ShowStateMachine() string

ShowStateMachine returns a string representation of the state machine

func (*StateMachineImpl[S, E, P]) Verify 

func (sm *StateMachineImpl[S, E, P]) Verify(sourceStateId S, event E) bool

Verify checks if there is a valid transition for the given state and event

type ToAmongStep 

type ToAmongStep interface{}

type ToInterface 

type ToInterface[S comparable, E comparable, P any] interface {
	// On specifies the triggering event
	On(event E) OnInterface[S, E, P]
}

ToInterface is the interface for specifying the target state of a transition

type ToStep 

type ToStep interface{}

type Transition 

type Transition[S comparable, E comparable, P any] struct {
	Source    *State[S, E, P]
	Target    *State[S, E, P]
	Event     E
	Condition Condition[P]
	Action    Action[S, E, P]
	TransType TransitionType
}

Transition represents a state transition

func (*Transition[S, E, P]) Transit 

func (t *Transition[S, E, P]) Transit(payload P, checkCondition bool) (*State[S, E, P], error)

Transit executes the transition

type TransitionBuilder 

type TransitionBuilder[S comparable, E comparable, P any, Next any] struct {
	// contains filtered or unexported fields
}

TransitionBuilder builds individual transitions

func (*TransitionBuilder[S, E, P, Next]) From 

func (b *TransitionBuilder[S, E, P, Next]) From(state S) FromInterface[S, E, P]

From specifies the source state Parameters: 

state: Source state

Returns: 

The transition builder for method chaining

func (*TransitionBuilder[S, E, P, Next]) On 

func (b *TransitionBuilder[S, E, P, Next]) On(event E) OnInterface[S, E, P]

On specifies the triggering event Parameters: 

event: The event that triggers this transition

Returns: 

The transition builder for method chaining

func (*TransitionBuilder[S, E, P, Next]) Perform 

func (b *TransitionBuilder[S, E, P, Next]) Perform(action Action[S, E, P])

Perform specifies the action to execute during the transition Parameters: 

action: The action to execute when the transition occurs

func (*TransitionBuilder[S, E, P, Next]) PerformFunc 

func (b *TransitionBuilder[S, E, P, Next]) PerformFunc(actionFunc func(from, to S, event E, payload P) error)

PerformFunc specifies a function as the action to execute during the transition Parameters: 

actionFunc: The function to execute when the transition occurs

func (*TransitionBuilder[S, E, P, Next]) To 

func (b *TransitionBuilder[S, E, P, Next]) To(state S) ToInterface[S, E, P]

To specifies the target state Parameters: 

state: Target state

Returns: 

The transition builder for method chaining

func (*TransitionBuilder[S, E, P, Next]) When 

func (b *TransitionBuilder[S, E, P, Next]) When(condition Condition[P]) WhenInterface[S, E, P]

When specifies the condition for the transition Parameters: 

condition: The condition that must be satisfied for the transition to occur

Returns: 

The transition builder for method chaining

func (*TransitionBuilder[S, E, P, Next]) WhenFunc 

func (b *TransitionBuilder[S, E, P, Next]) WhenFunc(conditionFunc func(payload P) bool) WhenInterface[S, E, P]

WhenFunc specifies a function as the condition for the transition Parameters: 

conditionFunc: The function that must return true for the transition to occur

Returns: 

The transition builder for method chaining

type TransitionStarterInterface 

type TransitionStarterInterface[S comparable, E comparable, P any] interface {
	// ExternalTransition starts defining an external transition
	ExternalTransition() ExternalTransitionBuilderInterface[S, E, P]

	// InternalTransition starts defining an internal transition
	InternalTransition() InternalTransitionBuilderInterface[S, E, P]

	// ExternalTransitions starts defining multiple external transitions
	ExternalTransitions() ExternalTransitionsBuilderInterface[S, E, P]

	// ExternalParallelTransition starts defining an external parallel transition
	ExternalParallelTransition() ExternalParallelTransitionBuilderInterface[S, E, P]
}

TransitionStarterInterface is the interface for starting a transition definition

type TransitionType 

type TransitionType int

TransitionType defines the type of transition 

const (
	// External transitions change the state from source to target
	External TransitionType = iota
	// Internal transitions don't change the state
	Internal
)

type WhenInterface 

type WhenInterface[S comparable, E comparable, P any] interface {
	// Perform specifies the action to execute during the transition
	Perform(action Action[S, E, P])

	// PerformFunc specifies a function as the action to execute during the transition
	PerformFunc(actionFunc func(from, to S, event E, payload P) error)
}

WhenInterface is the interface for specifying the condition of a transition

type WhenStep 

type WhenStep interface{}

type WithinStep 

type WithinStep interface{}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy