public static TContext PerformStraightforward <TContext, TStateId>(
TContext context,
IStatefulTask <TContext, TStateId> initialTask,
IReadOnlyDictionary <TStateId, IStatefulTask <TContext, TStateId> > transitions)
{
// We can log type names of state and tasks but it will be helpful for debugging.
Logger.Debug($"Initial state: {context}");
IStatefulTask <TContext, TStateId> currentTask = initialTask;
try
{
Logger.Debug("Starting performing.");
while (!currentTask.IsFinal)
{
Logger.Debug($"Executing task: {currentTask}.");
TStateId stateId = currentTask.DoAction(context);
currentTask = transitions[stateId];
Logger.Debug($"Current state: {context}.");
}
// Perform the final task.
Logger.Debug($"Executing task: {currentTask}.");
currentTask.DoAction(context);
}
catch (Exception ex)
{
Logger.Exception(ex, "Exception occurred during state machine performing.");
}
Logger.Debug($"Final state: {context}");
return(context);
}
public static IStateMachineExecutor <TState, TStateId> GoTo <TState, TStateId>(
this IStateMachineFiller <TState, TStateId> filler,
IStatefulTask <TState, TStateId> statefulTask)
where TState : class
{
return(filler.FillExecutor(statefulTask));
}
public static TState PerformStraightforward <TState>(TState initialState,
IStatefulTask <TState> initialTask)
where TState : class
{
Logger.Message($"Initial state: {initialState}");
TState currentState = initialState;
IStatefulTask <TState> currentTask = initialTask;
try
{
Logger.Message("Starting performing.");
while (!currentTask.IsFinal)
{
Logger.Message($"Executing task: {currentTask}.");
currentTask = currentTask.DoAction(currentState);
Logger.Message($"Current state: {currentState}.");
}
// Perform the final task.
Logger.Message($"Executing task: {currentTask}.");
currentTask.DoAction(currentState);
}
catch (Exception ex)
{
Logger.Exception(ex, "Exception occured during state machine performing.");
}
Logger.Message($"Final state: {currentState}");
return(currentState);
}
public static TState PerformStraightforward <TState, TStateId>(TState initialState,
IStatefulTask <TState, TStateId> initialTask,
IReadOnlyDictionary <TStateId, IStatefulTask <TState, TStateId> > transitions)
where TState : class
{
Logger.Message($"Initial state: {initialState}");
TState currentState = initialState;
IStatefulTask <TState, TStateId> currentTask = initialTask;
try
{
Logger.Message("Starting performing.");
while (!currentTask.IsFinal)
{
Logger.Message($"Executing task: {currentTask}.");
TStateId stateId = currentTask.DoAction(currentState);
currentTask = transitions[stateId];
Logger.Message($"Current state: {currentState}.");
}
// Perform the final task.
Logger.Message($"Executing task: {currentTask}.");
currentTask.DoAction(currentState);
}
catch (Exception ex)
{
Logger.Exception(ex, "Exception occured during perform.");
}
Logger.Message($"Final state: {currentState}");
return(currentState);
}
public override bool MoveNext()
{
bool isFinal = _current.IsFinal;
// Perform the task before getting IsFinal flag because it can be changed.
_current = _current.DoAction(State);
return(!isFinal);
}
public StateMachineUntilFinalStateExecutor(
TState initialState,
IStatefulTask <TState> initialTask)
{
State = initialState.ThrowIfNull(nameof(initialTask));
_initialTask = initialTask.ThrowIfNull(nameof(initialTask));
_current = initialTask;
}
private static IStateMachineBuilderWithoutStateId <Context, StateId, IStatefulTask <Context, StateId> > FillExecutor(
IStatefulTask <Context, StateId> initialTask)
{
return(initialTask.AsInitial(StateId.Initial)
.On(StateId.StateA).GoTo(new TaskA())
.On(StateId.StateB).GoTo(new TaskB())
.On(StateId.StateC).GoTo(new TaskC())
.OnFinalGoToSelfLoop(StateId.Final));
}
public override bool MoveNext()
{
if (_current is null)
{
throw new InvalidOperationException("Invalid stateful task to process.");
}
bool isFinal = _current.IsFinal;
// Perform the task after getting 'IsFinal' flag because we can face final task and do not call it 'DoAction' method.
_current = _current.DoAction(State);
return(!isFinal);
}
public IStateMachineExecutor <TState, TStateId> FillExecutor(
IStatefulTask <TState, TStateId> statefulTask)
{
if (statefulTask is null)
{
throw new ArgumentException(
"Invalid stateful task to fill executor.", nameof(statefulTask)
);
}
Executor[StateIdToFill] = statefulTask;
return(Executor);
}
public IStateMachineExecutor <TState, TStateId> FillExecutor(
IStatefulTask <TState, TStateId> statefulTask)
{
Executor[StateIdToFill] = statefulTask;
return(Executor);
}
public NoOpNonFinalStatefulTask(IStatefulTask <TState> stateIdToMove)
{
_stateToMove = stateIdToMove;
}
public static IStateMachineExecutor <TState, TStateId> PerformUntilFinalState <TState, TStateId>(
this IStatefulTask <TState, TStateId> initialTask, TState initialState)
where TState : class
{
return(StateMachineUntilFinalStateExecutor.CreateNew(initialState, initialTask));
}
public static IStateMachineExecutor <TState> PerformUntilFinalState <TState>(
this IStatefulTask <TState> initialTask, TState initialState)
where TState : class
{
return(new StateMachineUntilFinalStateExecutor <TState>(initialState, initialTask));
}
// To simplify call (no need in generic arguments).
public static IStateMachineBuilderWithoutStateId <TContext, TStateId, IStatefulTask <TContext, TStateId> > AsInitial <TContext, TStateId>(
this IStatefulTask <TContext, TStateId> initialTask,
TStateId initialStateId)
{
return(initialTask.AsInitial <TContext, TStateId, IStatefulTask <TContext, TStateId> >(initialStateId));
}
