41 lines
1.2 KiB
Go
41 lines
1.2 KiB
Go
// Package flow allows an asynchronous process to be written sequentially.
|
|
package flow
|
|
|
|
// Flow represents any multi-stage process that relies on callbacks to advance
|
|
// to other stages. It allows for such a process to be laid flat instead of
|
|
// nested.
|
|
type Flow struct {
|
|
// Transition specifies a function to call before moving on to another
|
|
// stage, such as clearing out a container so that new elements may be
|
|
// added to it.
|
|
Transition func ()
|
|
|
|
// Stages is a map that pairs stage names with stage functions.
|
|
Stages map [string] func ()
|
|
|
|
stage string
|
|
}
|
|
|
|
// Switch transitions the flow to a different stage, running the specified
|
|
// transition callback first.
|
|
func (flow Flow) Switch (stage string) {
|
|
stageCallback := flow.Stages[stage]
|
|
if stageCallback == nil { return }
|
|
if flow.Transition != nil { flow.Transition() }
|
|
flow.stage = stage
|
|
stageCallback()
|
|
}
|
|
|
|
// SwitchFunc returns a function that calles Switch with the specfied stage
|
|
// name. This is useful for creating callbacks.
|
|
func (flow Flow) SwitchFunc (stage string) (callback func ()) {
|
|
return func () {
|
|
flow.Switch(stage)
|
|
}
|
|
}
|
|
|
|
// Stage returns the name of the current stage the flow is on.
|
|
func (flow Flow) Stage () (name string) {
|
|
return flow.stage
|
|
}
|