public NextAction(int index, SyntaxNode node, SyntaxToken lastToken, IActionHolder <TArgument> actionCache)
{
_index = index;
_node = node;
_lastToken = lastToken;
_actionCache = actionCache;
}
private void ExecuteExitAction(IActionHolder actionHolder, ITransitionContext <TState, TEvent> context)
{
try
{
actionHolder.Execute(context.EventArgument);
}
catch (Exception exception)
{
this.HandleExitActionException(context, exception);
}
}
private void ExecuteExitAction(IActionHolder actionHolder, IStateContext <TState, TEvent> stateContext)
{
try
{
actionHolder.Execute();
}
catch (Exception exception)
{
this.HandleExitActionException(stateContext, exception);
}
}
private void ExecuteEntryAction(
IStateDefinition <TState, TEvent> stateDefinition,
IActionHolder actionHolder,
ITransitionContext <TState, TEvent> context)
{
try
{
actionHolder.Execute(context.EventArgument);
}
catch (Exception exception)
{
this.HandleEntryActionException(stateDefinition, context, exception);
}
}
private async Task ExecuteExitAction(
IStateDefinition <TState, TEvent> stateDefinition,
IActionHolder actionHolder,
ITransitionContext <TState, TEvent> context)
{
try
{
await actionHolder
.Execute(context.EventArgument)
.ConfigureAwait(false);
}
catch (Exception exception)
{
await this.HandleExitActionException(stateDefinition, context, exception)
.ConfigureAwait(false);
}
}
public void AddActions(JSONNode next, IActionHolder ah)
{
foreach (JSONNode actionSpec in next["actions"].Children)
{
string jsonString = actionSpec.ToString();
if (allActions.ContainsKey(actionSpec["type"].Value))
{
Type t = allActions[actionSpec["type"].Value];
Action action = JsonUtility.FromJson(jsonString, t) as Action;
if (actionSpec.HasKey("actions"))
{
AddActions(actionSpec, action);
}
ah.AddAction(action);
}
}
}
public NextAction(int index, SyntaxNode node, IActionHolder <TArgument> actionCache)
{
this.index = index;
this.node = node;
this.actionCache = actionCache;
}
private void AddContinuedOperations <TArg1>(int index, List <TArg1> arg1, SyntaxNode node, SyntaxToken lastToken, IActionHolder <TArg1> actionCache)
{
// If we have no remaining handlers to execute, then we'll execute our last handler
if (index >= _formattingRules.Count)
{
return;
}
else
{
// Call the handler at the index, passing a continuation that will come back to here with index + 1
var continuation = new NextAction <TArg1>(index + 1, node, lastToken, actionCache);
actionCache.NextOperation(index, arg1, node, lastToken, continuation);
return;
}
}
public EntryActionProxy(IActionHolder actionHolder, bool executeOnStart)
{
_actionHolder = actionHolder;
_executeOnStart = executeOnStart;
}
public void AddExitAction(IActionHolder action)
{
this.exitActions.Add(action);
}
public void AddExitAction(IActionHolder <TState, TInput> actionHolder)
{
exitActions.Add(actionHolder);
}
public void Remove(IActionHolder <TState, TInput> actionHolder)
{
_actionHolders.Remove(actionHolder);
}
public void Add(IActionHolder <TState, TInput> actionHolder)
{
_actionHolders.Add(actionHolder);
}
public ActionBuilder(IActionHolder builder, TflAction action) {
_builder = builder;
_action = action;
}
public void AddExitAction(IActionHolder action)
{
throw new NotImplementedException();
}
public void AddEntryAction(IActionHolder action)
{
this.entryActions.Add(action);
}
public ActionBuilder(IActionHolder builder, TflAction action)
{
_builder = builder;
_action = action;
}
public void AddEntryAction(IActionHolder <TState, TInput> actionHolder)
{
entryActions.Add(actionHolder);
}
