model

type EnterResult int

type EvalResult int

type FlowBehavior interface {

	// Start the flow instance.  Returning true indicates that the
	// flow can start and enter the specified tasks.
	// Return false indicates that the flow could not be started
	// at this time.
	Start(context FlowContext) (started bool, taskEntries []*TaskEntry)

	// StartErrorHandler start the error handler for the flow.
	// Return the list of tasks to start
	StartErrorHandler(context FlowContext) (taskEntries []*TaskEntry)

	// Resume the flow instance.  Returning true indicates that the
	// flow can resume.  Return false indicates that the flow
	// could not be resumed at this time.
	Resume(context FlowContext) (resumed bool)

	// TasksDone is called when a terminal task is Done.
	TaskDone(context FlowContext) (flowDone bool)

	// Done is called when the flow is done.
	Done(context FlowContext)
}

type FlowContext interface {

	// FlowDefinition returns the Flow definition associated with this context
	FlowDefinition() *definition.Definition

	// TaskInstances get the task instances
	TaskInstances() []TaskInstance

	// Status gets the state of the Flow instance
	Status() FlowStatus

	// Logger the logger for the flow instance
	Logger() log.Logger
}

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

type FlowStatus int

type LinkInstance interface {

	// Link returns the Link associated with this Link Instance
	Link() *definition.Link

	// Status gets the state of the Link instance
	Status() LinkStatus

	// SetStatus sets the state of the Link instance
	SetStatus(status LinkStatus)
}

type LinkStatus int

type TaskBehavior interface {

	// Enter determines if a Task is ready to be evaluated, or needs to be
	// skipped
	Enter(context TaskContext) (enterResult EnterResult)

	// Eval is called when a Task is being evaluated.  Returning true indicates
	// that the task is done.  If err is set, it indicates that the
	// behavior intends for the flow ErrorHandler to handle the error
	Eval(context TaskContext) (evalResult EvalResult, err error)

	// PostEval is called when a task that is waiting needs to be notified.
	// If err is set, it indicates that the behavior intends for the
	// flow ErrorHandler to handle the error
	PostEval(context TaskContext) (evalResult EvalResult, err error)

	// Done is called when Eval or PostEval return a result of DONE, indicating
	// that the task is done.  This step is used to finalize the task and
	// determine the next set of tasks to be entered.
	Done(context TaskContext) (notifyFlow bool, taskEntries []*TaskEntry, err error)

	// Skip is called when Enter returns a result of SKIP, indicating
	// that the task should be skipped.  This step is used to skip the task and
	// determine the next set of tasks to be entered.
	Skip(context TaskContext) (notifyFlow bool, taskEntries []*TaskEntry, propagateSkip bool)

	// Error is called when there is an issue executing Eval, it returns a boolean indicating
	// if it handled the error, otherwise the error is handled by the global error handler
	Error(context TaskContext, err error) (handled bool, taskEntries []*TaskEntry)
}

type TaskContext interface {

	// Status gets the state of the Task instance
	Status() TaskStatus

	// SetStatus sets the state of the Task instance
	SetStatus(status TaskStatus)

	// Task returns the Task associated with this context
	Task() *definition.Task

	// GetFromLinkInstances returns the instances of predecessor Links of the current task.
	GetFromLinkInstances() []LinkInstance

	// GetToLinkInstances returns the instances of successor Links of the current task.
	GetToLinkInstances() []LinkInstance

	// EvalLink evaluates the specified link
	EvalLink(link *definition.Link) (bool, error)

	// EvalActivity evaluates the Activity associated with the Task
	EvalActivity() (done bool, err error)

	// PostActivity does post evaluation of the Activity associated with the Task
	PostEvalActivity() (done bool, err error)

	GetSetting(name string) (value interface{}, exists bool)

	SetWorkingData(key string, value interface{})

	GetWorkingData(key string) (interface{}, bool)

	FlowLogger() log.Logger
}

type TaskEntry struct {
	Task      *definition.Task
	EnterCode int
}

type TaskInstance interface {

	// Task returns the Task associated with this Task Instance
	Task() *definition.Task

	// Status gets the state of the Task instance
	Status() TaskStatus
}

type TaskStatus int