statemachine

// Allocate space for 3 states, 3 commands and 10 requests in the channel.
sm := New(stateStopped, 3, 3)

// Allocate a new Context which is going to keep our data between
// the handler calls.
ctx := new(Context)
fmt.Printf("Context struct: %#v\n", ctx)

// RUN
sm.On(cmdRun, []State{
	stateStopped,
}, ctx.handleRun)

// STOP
sm.On(cmdStop, []State{
	stateRunning,
}, ctx.handleStop)

// CLOSE
sm.On(cmdClose, []State{
	stateStopped,
	stateRunning,
}, ctx.handleClose)

var (
	run  = &Event{cmdRun, nil}
	stop = &Event{cmdStop, nil}
	cls  = &Event{cmdClose, nil}
)

sm.Emit(run)
sm.Emit(stop)
sm.Emit(run)
sm.Emit(stop)

// Show how to write an event producer.
exit := make(chan struct{})

go func() {
	eventCh := make(chan *Event)
	go func() {
		eventCh <- run
		eventCh <- stop
		eventCh <- run
		eventCh <- cls
		close(exit)
	}()

	for {
		select {
		case event := <-eventCh:
			sm.Emit(event)
		case <-sm.TerminatedChannel():
			return
		}
	}
}()

// Wait for the inner goroutine to close the exit channel.
<-exit

// Close our state machine.
sm.Terminate()

// Wait for the state machine to terminate.
<-sm.TerminatedChannel()

fmt.Println("Goroutine exited")

Output:

Context struct: &statemachine.Context{seq:0}
Event number 1 received
STOPPED -> RUNNING by RUN
Event number 2 received
RUNNING -> STOPPED by STOP
Event number 3 received
STOPPED -> RUNNING by RUN
Event number 4 received
RUNNING -> STOPPED by STOP
Event number 5 received
STOPPED -> RUNNING by RUN
Event number 6 received
RUNNING -> STOPPED by STOP
Event number 7 received
STOPPED -> RUNNING by RUN
Event number 8 received
RUNNING -> CLOSED by CLOSE
Goroutine exited