public void OneInput(bool value)
{
Guid inputId = new Guid("A916E57F-A5C7-4426-AC9F-44396E4427E6");
StateMachineInput[] inputs =
{
new StateMachineInput
{
Id = inputId
},
};
var rootCondition = new StateMachineCondition()
{
ConditionType = ConditionType.Input,
SourceInputId = inputId
};
var instructions = _instructionFactory.GetInstructions(rootCondition, inputs);
bool[] inputValues = new bool[]
{
value
};
Assert.Equal(value, instructions.Evalutate(inputValues));
}
public ConditionViewModel(StateMachineCondition model,
TransitionEditorViewModel owner,
ConditionEditServiceManager serviceManager,
IMessageBoxService messageBoxService)
{
_model = model;
_owner = owner ?? throw new ArgumentNullException(nameof(owner));
_serviceManager = serviceManager ?? throw new ArgumentNullException(nameof(serviceManager));
_messageBoxService = messageBoxService ?? throw new ArgumentNullException(nameof(messageBoxService));
Conditions = new ConditionsViewModel(this);
if (model.Conditions != null)
{
foreach (var childCondition in model.Conditions)
{
Conditions.Add(new ConditionViewModel(childCondition, owner, serviceManager, _messageBoxService));
}
}
//Get the current editor
_editService = _serviceManager[model.ConditionType];
Fix();
AddConditionCommand = new RelayCommand(AddCondition, () => CanAddCondition);
DeleteCommand = new RelayCommand(Delete);
Conditions.CollectionChanged += ConditionsCollectionChanged;
}
public void OneInput()
{
Guid inputId = new Guid("A916E57F-A5C7-4426-AC9F-44396E4427E6");
StateMachineInput[] inputs =
{
new StateMachineInput
{
Id = inputId
},
};
var rootCondition = new StateMachineCondition()
{
ConditionType = ConditionType.Input,
SourceInputId = inputId
};
var instructions = _instructionFactory.GetInstructions(rootCondition, inputs);
Assert.Equal(1, instructions.Length);
Assert.Equal(OpCode.Push, instructions[0].OpCode);
Assert.NotNull(instructions[0].InputIndex);
Assert.Equal(0, instructions[0].InputIndex.Value);
}
public void NotInput(bool value, bool expected)
{
Guid inputId = new Guid("A916E57F-A5C7-4426-AC9F-44396E4427E6");
StateMachineInput[] inputs =
{
new StateMachineInput
{
Id = inputId
},
};
var rootCondition = new StateMachineCondition()
{
ConditionType = ConditionType.Not,
Conditions = new List <StateMachineCondition>(1)
{
new StateMachineCondition
{
ConditionType = ConditionType.Input,
SourceInputId = inputId
}
}
};
//Generate the instructions
var instructions = _instructionFactory.GetInstructions(rootCondition, inputs);
bool[] inputValues = new bool[]
{
value
};
Assert.Equal(expected, instructions.Evalutate(inputValues));
}
public void SimpleAnd()
{
Guid inputIdA = new Guid("A916E57F-A5C7-4426-AC9F-44396E4427E6");
Guid inputIdB = new Guid("9DFD98B0-FE1F-4A3E-B021-43617877A486");
StateMachineInput[] inputs =
{
new StateMachineInput
{
Id = inputIdA
},
new StateMachineInput
{
Id = inputIdB
},
};
//Condition (A & B)
var rootCondition = new StateMachineCondition()
{
ConditionType = ConditionType.And,
Conditions = new List <StateMachineCondition>(2)
{
new StateMachineCondition()
{
ConditionType = ConditionType.Input,
SourceInputId = inputIdA,
},
new StateMachineCondition()
{
ConditionType = ConditionType.Input,
SourceInputId = inputIdB,
}
}
};
//Should be: Push 0, Push 1, And
//Generate the instructions
var instructions = _instructionFactory.GetInstructions(rootCondition, inputs);
Assert.Equal(3, instructions.Length);
//0
Assert.Equal(OpCode.Push, instructions[0].OpCode);
Assert.NotNull(instructions[0].InputIndex);
Assert.Equal((byte)0, instructions[0].InputIndex.Value);
//1
Assert.Equal(OpCode.Push, instructions[1].OpCode);
Assert.NotNull(instructions[1].InputIndex);
Assert.Equal((byte)1, instructions[1].InputIndex.Value);
//2
Assert.Equal(OpCode.And, instructions[2].OpCode);
Assert.Null(instructions[2].InputIndex);
}
private void AddInstruction(IList <Instruction> instructions, StateMachineCondition condition, StateMachineInput[] inputs)
{
if (condition == null)
{
return;
}
switch (condition.ConditionType)
{
case ConditionType.Input:
if (condition.SourceInputId == null)
{
throw new InvalidOperationException($"An input condition was specified without an input id.");
}
var input = inputs.FirstOrDefault(i => i.Id == condition.SourceInputId.Value);
if (input == null)
{
throw new InvalidOperationException($"Input with id '{condition.SourceInputId.Value}' could not be found.");
}
int inputIndex = Array.IndexOf(inputs, input);
instructions.Add(new Instruction(OpCode.Push, (byte)inputIndex));
break;
case ConditionType.Or:
AddCompoundInstruction(instructions, condition, OpCode.Or, inputs);
break;
case ConditionType.And:
AddCompoundInstruction(instructions, condition, OpCode.And, inputs);
break;
case ConditionType.Not:
if (condition.Conditions.Count != 1)
{
throw new InvalidOperationException($"NOT conditions must have one and only one child conditions. This had {condition.Conditions.Count}.");
}
//Add the child instructions
AddInstruction(instructions, condition.Conditions[0], inputs);
//Now add the note instruction
instructions.Add(new Instruction(OpCode.Not));
break;
default:
throw new NotSupportedException($"ConditionType '{condition.ConditionType}'");
}
}
public ExceptionActivityBinder <TInstance, TException> If(StateMachineCondition <TInstance> condition,
Func <ExceptionActivityBinder <TInstance, TException>, ExceptionActivityBinder <TInstance, TException> > activityCallback)
{
ExceptionActivityBinder <TInstance, TException> binder = new CatchExceptionActivityBinder <TInstance, TException>(_machine, _event);
binder = activityCallback(binder);
var conditionBinder = new ConditionalActivityBinder <TInstance>(_event, condition, binder);
return(new CatchExceptionActivityBinder <TInstance, TException>(_machine, _event, _activities, conditionBinder));
}
public EventActivityBinder <TInstance, TData> IfElse(StateMachineCondition <TInstance, TData> condition,
Func <EventActivityBinder <TInstance, TData>, EventActivityBinder <TInstance, TData> > thenActivityCallback,
Func <EventActivityBinder <TInstance, TData>, EventActivityBinder <TInstance, TData> > elseActivityCallback)
{
var thenBinder = GetBinder(thenActivityCallback);
var elseBinder = GetBinder(elseActivityCallback);
var conditionBinder = new ConditionalActivityBinder <TInstance, TData>(_event, condition, thenBinder, elseBinder);
return(new DataEventActivityBinder <TInstance, TData>(_machine, _event, _filter, _activities, conditionBinder));
}
EventActivityBinder <TInstance> EventActivityBinder <TInstance> .If(StateMachineCondition <TInstance> condition,
Func <EventActivityBinder <TInstance>, EventActivityBinder <TInstance> > activityCallback)
{
EventActivityBinder <TInstance> binder = new TriggerEventActivityBinder <TInstance>(_machine, _event);
binder = activityCallback(binder);
var conditionBinder = new ConditionalActivityBinder <TInstance>(_event, condition, binder);
return(new TriggerEventActivityBinder <TInstance>(_machine, _event, _filter, _activities, conditionBinder));
}
public Instruction[] GetInstructions(StateMachineCondition condition, StateMachineInput[] inputs)
{
List <Instruction> instructions = new List <Instruction>();
AddInstruction(instructions, condition, inputs);
var temp = instructions.ToArray();
temp.Validate(inputs.Length);
return(temp);
}
private static void WriteEntry(BinaryWriter writer, int entryIndex, StateMachineEntry entry)
{
writer.Write(Magics.Entry);
writer.Write(entryIndex);
writer.WriteNullTerminatedString(entry.Name);
for (int conditionIndex = 0; conditionIndex < entry.Conditions.Count; conditionIndex++)
{
StateMachineCondition condition = entry.Conditions[conditionIndex];
WriteCondition(writer, entryIndex, conditionIndex, condition);
}
}
public static ConditionViewModel ToViewModel(this StateMachineCondition conditionMetadata, TransitionEditorViewModel owner)
{
if (conditionMetadata == null)
{
return(null);
}
return(new ConditionViewModel(
conditionMetadata,
owner,
ApplicationContainer.Container.Resolve <ConditionEditServiceManager>(),
ApplicationContainer.Container.Resolve <IMessageBoxService>()));
}
private void SetConditions(StateMachineCondition model)
{
if (model.Conditions == null)
{
Conditions = new List <StateMachineConditionViewModel>();
}
else
{
foreach (var item in model.Conditions)
{
Conditions.Add(new StateMachineConditionViewModel(item));
}
}
}
public void SimpleCompound(bool a, bool b, ConditionType conditionType, bool expected)
{
Guid inputIdA = new Guid("A916E57F-A5C7-4426-AC9F-44396E4427E6");
Guid inputIdB = new Guid("9DFD98B0-FE1F-4A3E-B021-43617877A486");
StateMachineInput[] inputs =
{
new StateMachineInput
{
Id = inputIdA
},
new StateMachineInput
{
Id = inputIdB
},
};
//Condition (A & B)
var rootCondition = new StateMachineCondition()
{
ConditionType = conditionType,
Conditions = new List <StateMachineCondition>(2)
{
new StateMachineCondition()
{
ConditionType = ConditionType.Input,
SourceInputId = inputIdA,
},
new StateMachineCondition()
{
ConditionType = ConditionType.Input,
SourceInputId = inputIdB,
}
}
};
//Generate the instructions
var instructions = _instructionFactory.GetInstructions(rootCondition, inputs);
bool[] inputValues = new bool[]
{
a,
b
};
Assert.Equal(expected, instructions.Evalutate(inputValues));
}
private void AddCompoundInstruction(IList <Instruction> instructions, StateMachineCondition condition, OpCode opCode, StateMachineInput[] inputs)
{
if (condition.Conditions == null)
{
throw new InvalidOperationException("A compound logical type had null children");
}
for (int conditionIndex = 0; conditionIndex < condition.Conditions.Count; conditionIndex++)
{
AddInstruction(instructions, condition.Conditions[conditionIndex], inputs);
if (conditionIndex != 0)
{
instructions.Add(new Instruction(opCode));
}
}
}
private StringBuilder AddCondition(StateMachineCondition condition, StateMachineInput[] inputs)
{
StringBuilder s = new StringBuilder();
if ((condition.ConditionType == ConditionType.Input) && inputs != null)
{
Guid conditionGuid = condition.SourceInputId.Value;
StateMachineInput input = inputs.FirstOrDefault(i => i.Id == conditionGuid);
if (input != null)
{
if (!_conditionGuids.Contains(conditionGuid))
{
_conditionGuids.Add(conditionGuid);
}
s.Append($" {input.Name}");
}
}
else if ((condition.ConditionType == ConditionType.Not) && inputs != null)
{
s.Append("!");
s.Append(AddCondition(condition.Conditions.First(), inputs));
}
else if (condition.ConditionType == ConditionType.And || condition.ConditionType == ConditionType.Or)
{
s.Append(" ( ");
string operation = condition.ConditionType == ConditionType.And ? " AND " : " OR ";
for (int i = 0; i < condition.Conditions.Count; i++)
{
var item = condition.Conditions[i];
if (i > 0)
{
s.Append(operation);
}
s.Append(AddCondition(item, inputs));
}
s.Append(" ) ");
}
return(s);
}
private void AddCondition()
{
try
{
if (!CanAddCondition)
{
return;
}
var model = new StateMachineCondition()
{
ConditionType = ConditionType.Input
};
var condition = new ConditionViewModel(model, _owner, _serviceManager, _messageBoxService);
Conditions.Add(condition);
}
catch (Exception ex)
{
_messageBoxService.Show(ex);
}
}
private static StateMachineCondition ReadCondition(Stream stream, BinaryReader reader)
{
var newCondition = new StateMachineCondition
{
ParentEntryIndex = reader.ReadInt32(),
GotoEntry = reader.ReadInt32(),
Type = reader.ReadInt32(),
Expression = reader.ReadNullTerminatedString(),
Value = reader.ReadNullTerminatedString()
};
while (stream.Position < stream.Length)
{
if (reader.ReadInt32() != Magics.Action)
{
stream.Position -= 4;
break;
}
newCondition.Actions.Add(ReadAction(reader));
}
return(newCondition);
}
public ConditionalActivityBinder(Event @event, StateMachineCondition <TInstance> condition,
EventActivities <TInstance> thenActivities, EventActivities <TInstance> elseActivities)
: this(@event, context => Task.FromResult(condition(context)), thenActivities, elseActivities)
{
}
public ConditionalActivityBinder(Event @event, StateMachineCondition <TInstance> condition, EventActivities <TInstance> activities)
{
_activities = activities;
_condition = condition;
_event = @event;
}
public ConditionActivity(StateMachineCondition <TInstance> condition, Behavior <TInstance> behavior)
{
_condition = condition;
_behavior = behavior;
}
private static void WriteCondition(BinaryWriter writer, int entryIndex, int conditionIndex, StateMachineCondition condition)
{
writer.Write(Magics.Condition);
writer.Write(entryIndex);
writer.Write(condition.GotoEntry);
writer.Write(condition.Type);
writer.WriteNullTerminatedString(condition.Expression);
writer.WriteNullTerminatedString(condition.Value);
foreach (StateMachineAction action in condition.Actions)
{
WriteAction(writer, entryIndex, conditionIndex, action);
}
}
public StateMachineConditionViewModel(StateMachineCondition model)
{
_model = model ?? throw new ArgumentNullException(nameof(model));
SetConditions(model);
}
EventActivityBinder <TInstance, TData> EventActivityBinder <TInstance, TData> .If(StateMachineCondition <TInstance, TData> condition,
Func <EventActivityBinder <TInstance, TData>, EventActivityBinder <TInstance, TData> > activityCallback)
{
return(IfElse(condition, activityCallback, _ => _));
}
