private void AddSwitchOptionAndSaveCommand(TriggeringArguments <int, char> arg)
{
options[key] = true;
inputs.Add(new Input(name, arguments.ToArray(), new Dictionary <string, object>(options)));
arguments.Clear();
options.Clear();
}
private void ProcessSyntaxError(TriggeringArguments <int, char> arg)
{
int index = arg.InputPosition;
string prefix = rawInput.Trim().Substring(0, index);
string post = rawInput.Trim().Substring(index);
StringBuilder builder = new StringBuilder(rawInput.Length * 2);
builder.AppendLine($"syntax error at {index}:");
builder.AppendLine(rawInput);
for (int i = 0; i < index; i++)
{
builder.Append(' ');
}
builder.Append('^');
builder.AppendLine();
errorMessage = builder.ToString();
arg.FollowingAction = FollowingAction.Stop;
arg.Handled = true;
}
private void SaveOptionFromValueArray(TriggeringArguments <int, char> arg) => options[key] = ConsumeValueArray();
private void AddArgumentToValueArrayAndSaveArgumentsAndSaveCommand(TriggeringArguments <int, char> arg)
{
valueArray.Add(ConsumeValueBuilder());
arguments.Add(ConsumeValueArray());
SaveCommand(arg);
}
private void AddInputToValueBuilder(TriggeringArguments <int, char> arg) => valueBuilder.Append(arg.Input);
private void WriteString(TriggeringArguments <int, char> arg) => WriteWithColor(STRING_COLOR);
private void WritePipeSeperator(TriggeringArguments <int, char> arg) => WriteWithColor(PIPE_SEPERATOR_COLOR);
private void WriteCurrent(TriggeringArguments <int, char> arg) => output = true;
private void SaveKey(TriggeringArguments <int, char> arg) => key = ConsumeValueBuilder();
private void AddValueBuilderToArguments(TriggeringArguments <int, char> arg) => arguments.Add(ConsumeValueBuilder());
private void AddValueBuilderToValueArray(TriggeringArguments <int, char> arg) => valueArray.Add(ConsumeValueBuilder());
private void SaveNameOnlyCommand(TriggeringArguments <int, char> arg) => inputs.Add(new Input(name, new object[0], new Dictionary <string, object>()));
private void SaveCommandNameAndSaveCommand(TriggeringArguments <int, char> arg)
{
name = ConsumeValueBuilder();
inputs.Add(new Input(name, new object[0], new Dictionary <string, object>()));
}
private void SaveCommandName(TriggeringArguments <int, char> arg) => name = ConsumeValueBuilder();
private void SaveOptionFromValueArrayAndSaveCommand(TriggeringArguments <int, char> arg)
{
options[key] = ConsumeValueArray();
SaveCommand(arg);
}
private void AddValueBuilderToValueArrayAndSaveOptionFromValueArrayAndSaveCommand(TriggeringArguments <int, char> arg)
{
valueArray.Add(ConsumeValueBuilder());
options[key] = ConsumeValueArray();
SaveCommand(arg);
}
private void AddSwitchOption(TriggeringArguments <int, char> arg) => options[key] = true;
private void NoWrite(TriggeringArguments <int, char> arg) => output = false;
private void SaveArguments(TriggeringArguments <int, char> arg) => arguments.Add(ConsumeValueArray());
private void WriteCommandName(TriggeringArguments <int, char> arg) => WriteWithColor(COMMAND_NAME_COLOR);
private void SaveArgumentsAndSaveCommand(TriggeringArguments <int, char> arg)
{
arguments.Add(ConsumeValueArray());
SaveCommand(arg);
}
private void WriteParameter(TriggeringArguments <int, char> arg) => WriteWithColor(PARAMETER_COLOR);
private void SaveArgumentFromValueBuilderAndSaveCommand(TriggeringArguments <int, char> arg)
{
arguments.Add(ConsumeValueBuilder());
SaveCommand(arg);
}
private void WriteEscape(TriggeringArguments <int, char> arg) => WriteWithColor(ESCAPE_COLOR);
public bool Transform(int position, TInput input, IEnumerable <TInput> inputs, StateMachine.TriggerType triggerType, out TState newState, out FollowingAction followingAction, out object shiftContext, out object stateMapper, out object callback, out object callbackData)
{
object context = null;
object mapper = null;
object endcall = null;
object calldata = null;
foreach (TriggerRecord <TState, TInput> triggerRecord in transformations)
{
switch (triggerRecord.Type)
{
case TriggerType.Trigger:
if (input.Equals(triggerRecord.Trigger))
{
newState = triggerRecord.NewState;
followingAction = FireTriggeringAction(triggerRecord, newState);
shiftContext = context;
stateMapper = mapper;
callback = endcall;
callbackData = calldata;
return(true);
}
break;
case TriggerType.Condition:
if (triggerRecord.Condition(State, input))
{
newState = triggerRecord.NewState;
followingAction = FireTriggeringAction(triggerRecord, newState);
shiftContext = context;
stateMapper = mapper;
callback = endcall;
callbackData = calldata;
return(true);
}
break;
case TriggerType.Always:
newState = triggerRecord.NewState;
followingAction = FireTriggeringAction(triggerRecord, newState);
shiftContext = context;
stateMapper = mapper;
callback = endcall;
callbackData = calldata;
return(true);
case TriggerType.AlwaysWithEvaluator:
newState = triggerRecord.Evaluator(State, input);
followingAction = FireTriggeringAction(triggerRecord, newState);
shiftContext = context;
stateMapper = mapper;
callback = endcall;
callbackData = calldata;
return(true);
}
}
newState = default(TState);
followingAction = FollowingAction.Continue;
shiftContext = context;
stateMapper = mapper;
callback = endcall;
callbackData = calldata;
return(false);
FollowingAction FireTriggeringAction(TriggerRecord <TState, TInput> triggerRecord, TState newstate)
{
TriggeringArguments <TState, TInput> arg = new TriggeringArguments <TState, TInput>(stateMachine, inputs, State, newstate, input, position, triggerType);
triggerRecord.TriggeringAction?.Invoke(arg);
if (!arg.Handled)
{
arg.FollowingAction = FollowingAction.Continue;
}
if (arg.FollowingAction == FollowingAction.Shift)
{
context = arg.ShiftContext;
mapper = arg.StateMapper;
endcall = arg.ShiftCallback;
calldata = arg.CallbackData;
}
return(arg.FollowingAction);
}
}
