sm

type ActionEntry struct {
	// Match is the message Tag value which causes this rule to trigger.
	Match int

	// Action is the processing function to call.
	Action ActionFunc

	// TrueState is the state ID to change to if Action returns true.
	TrueState StateIndex

	// FalseState is the state ID to change to if Action returns false.
	FalseState StateIndex

	// SaveNeeded is true if this entry requires a save state event.
	SaveNeeded bool
}

type ActionFunc func(ctx context.Context, machine *SM, msg Envelope) bool

type ActionState struct {
	NullState

	// Entries is the set of actions that can be taken in this state, with the
	// require incoming message match criteria, and state transitions.
	Entries []ActionEntry

	// Default is the action to take if no item in the Entries array matches
	// the incoming message.
	Default ActionFunc

	// OnEnter is the optional function to call when entering this state
	// (including transition from this state back to this state).
	OnEnter EnterFunc

	// OnLeave is the optional function to call when exiting this state
	// (including transition from this state back to this state).
	OnLeave LeaveFunc
}

type EnterFunc func(ctx context.Context, machine *SM) error

type Envelope interface {

	// Initialize sets up any linked span information, and the channel to use
	// for any completion responses.
	Initialize(ctx context.Context, tag int, ch chan *Response)

	// Ch returns the response channel.
	Ch() chan *Response

	// Tag returns the type ID to use when matching this message in the
	// action state table.
	Tag() int
}

type EnvelopeState struct {
	// contains filtered or unexported fields
}

type LeaveFunc func(ctx context.Context, machine *SM, nextState StateIndex)

type NullState struct{}

type Response struct {
	// Err holds any completion error code, or nil if the request was
	// successful.
	Err error

	// At contains the simulated time tick when the request completed its
	// processing.
	At int64

	// Msg holds any extended results information, or nil if there either is
	// none, or if an error is returned.
	Msg interface{}
}

type SM struct {
	common.Guarded

	// CurrentIndex holds the index to the current state
	CurrentIndex StateIndex

	// Current is a pointer to the current state
	Current State

	// FirstState is the index to the starting state
	FirstState StateIndex

	// States holds the map of known state index values to state implementations
	States map[StateIndex]State

	// Parent points to the structure that holds this state machine, and likely
	// holds global context that the state actions need.
	Parent interface{}

	// Terminated is true if the state machine has reached its final state.
	Terminated bool

	// EnteredAt is the simulated time tick when the current state was entered.
	EnteredAt int64

	// Name is the string that can be used to identify this particular instance.
	Name string

	// Saver is the function responsible for saving the state machine state to
	// an external store at the completion of an operation.
	Saver SaveHandler
}

type SaveHandler func(ctx context.Context, machine *SM, starting bool) error

type StartSM struct {
	EnvelopeState
}

type State interface {

	// Enter is called when a state transition moves to this state
	Enter(ctx context.Context, sm *SM) error

	// Receive is called on the active start implementation when a new
	// incoming message arrives.  It returns true if this is a message that
	// modifies the logical state machine state, such that it requires the
	// contents to be saved.
	Receive(ctx context.Context, machine *SM, msg Envelope) bool

	// Leave is called when a state transition moves away from this state
	Leave(ctx context.Context, sm *SM, nextState StateIndex)
}

type StateDecl func() (bool, StateIndex, State)

type StateIndex interface {
	fmt.Stringer
}

type StopSM struct {
	EnvelopeState
}