private object GetObjectValue(Flow flow)
{
object obj = flow.GetValue <object>(arguments[0]);
for (int i = 1; i < argumentCount; i++)
{
switch (OperationType)
{
case MathType.Add:
obj = OperatorUtility.Add(obj, flow.GetValue <object>(arguments[i]));
break;
case MathType.Subtract:
obj = OperatorUtility.Subtract(obj, flow.GetValue <object>(arguments[i]));
break;
case MathType.Multiply:
obj = OperatorUtility.Multiply(obj, flow.GetValue <object>(arguments[i]));
break;
case MathType.Divide:
obj = OperatorUtility.Divide(obj, flow.GetValue <object>(arguments[i]));
break;
default:
break;
}
}
return(obj);
}
public override object Operation(IEnumerable <object> values)
{
var valueList = values.ToList();
var result = OperatorUtility.Add(valueList[0], valueList[1]);
for (int i = 2; i < valueList.Count; i++)
{
result = OperatorUtility.Add(result, valueList[i]);
}
return(result);
}
public ControlOutput Enter(Flow flow)
{
var data = flow.stack.GetElementData <Data>(this);
object currentValue = flow.GetValue <object>(input);
if (!OperatorUtility.Equal(data.lastValue, currentValue))
{
data.lastValue = currentValue;
flow.SetValue(lastValue, currentValue);
return(onChange);
}
return(null);
}
public override void Visit(UnaryExpression unary)
{
// Recursively evaluates the underlying expression
unary.Expression.Accept(this);
switch (unary.Type)
{
case UnaryExpressionType.Not:
Result = !ConversionUtility.Convert <bool>(Result);
break;
case UnaryExpressionType.Negate:
Result = OperatorUtility.Negate(Result);
break;
case UnaryExpressionType.BitwiseNot:
Result = OperatorUtility.Not(Result);
break;
}
}
private static bool CanOverflow(OperatorImplementation impl)
{
if (!OperatorUtility.CanOverflow(impl.Key.Op))
{
return(false);
}
if (impl.CommonType == typeof(Int32) && IsSmallInt(impl.Key.Arg1Type) && IsSmallInt(impl.Key.Arg2Type))
{
return(false);
}
if (impl.CommonType == typeof(double) || impl.CommonType == typeof(Single))
{
return(false);
}
if (impl.CommonType == typeof(BigInteger))
{
return(false);
}
return(true);
}
public override void Init(ParsingContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
Target = AddChild(NodeUseType.ValueWrite, "To", treeNode.MappedChildNodes[0]);
//Get Op and baseOp if it is combined assignment
AssignmentOp = treeNode.MappedChildNodes[1].FindTokenAndGetText();
if (string.IsNullOrEmpty(AssignmentOp))
{
AssignmentOp = "=";
}
BinaryExpressionType = CustomExpressionTypes.NotAnExpression;
//There maybe an "=" sign in the middle, or not - if it is marked as punctuation; so we just take the last node in child list
Expression = AddChild(NodeUseType.ValueRead, "Expr", treeNode.LastChild);
AsString = AssignmentOp + " (assignment)";
// TODO: this is not always correct: in Pascal the assignment operator is :=.
IsAugmented = AssignmentOp.Length > 1;
if (IsAugmented)
{
//it is combined op
base.ExpressionType = context.GetOperatorExpressionType(AssignmentOp);
BinaryExpressionType = OperatorUtility.GetBinaryOperatorForAugmented(this.ExpressionType);
Target.UseType = NodeUseType.ValueReadWrite;
}
}
private bool GenericComparison(object a, object b)
{
return(OperatorUtility.Equal(a, b));
}
public override object Operation(object a, object b)
{
return(OperatorUtility.Divide(a, b));
}
protected override bool GenericComparison(object a, object b)
{
return(OperatorUtility.LessThan(a, b));
}
private bool GetValue(Flow flow)
{
switch (BranchingType)
{
case BranchType.And:
foreach (var item in arguments)
{
if (!flow.GetValue <bool>(item))
{
return(false);
}
}
return(true);
case BranchType.Or:
foreach (var item in arguments)
{
if (flow.GetValue <bool>(item))
{
return(true);
}
}
return(false);
case BranchType.GreaterThan:
{
bool NumericComparison(float a, float b, bool allowEquals)
{
return((a > b) || (allowEquals && Mathf.Approximately(a, b)));
}
return(NumericComparison(flow.GetValue <float>(arguments[0]), flow.GetValue <float>(arguments[1]), AllowEquals));
}
case BranchType.LessThan:
{
bool NumericComparison(float a, float b, bool allowEquals)
{
return((a < b) || (allowEquals && Mathf.Approximately(a, b)));
}
return(NumericComparison(flow.GetValue <float>(arguments[0]), flow.GetValue <float>(arguments[1]), AllowEquals));
}
case BranchType.Equal:
if (Numeric)
{
var target = flow.GetValue <float>(arguments[0]);
for (int i = 1; i < arguments.Count; i++)
{
Debug.Log(flow.GetValue <float>(arguments[i]));
if (!Mathf.Approximately(target, flow.GetValue <float>(arguments[i])))
{
return(false);
}
}
return(true);
}
else
{
var target = flow.GetValue <object>(arguments[0]);
for (int i = 1; i < arguments.Count; i++)
{
if (!OperatorUtility.Equal(target, flow.GetValue <object>(arguments[i])))
{
return(false);
}
}
return(true);
}
default:
return(false);
}
}
public override object Operation(object a, object b)
{
return(OperatorUtility.Subtract(a, b));
}
private bool NotEqual(Flow flow)
{
return(OperatorUtility.NotEqual(flow.GetValue(a), flow.GetValue(b)));
}
public override object Operation(object a, object b)
{
return(OperatorUtility.Multiply(a, b));
}
private bool GenericGreater(object a, object b)
{
return(OperatorUtility.GreaterThan(a, b));
}
private bool GenericNotEqual(object a, object b)
{
return(OperatorUtility.NotEqual(a, b));
}
private bool GenericLessOrEqual(object a, object b)
{
return(OperatorUtility.LessThanOrEqual(a, b));
}
public override void Visit(BinaryExpression binary)
{
// Simulate Lazy<Func<>> behavior for late evaluation
object leftValue = null;
Func <object> left = () =>
{
if (leftValue == null)
{
binary.LeftExpression.Accept(this);
leftValue = Result;
}
return(leftValue);
};
// Simulate Lazy<Func<>> behavior for late evaluation
object rightValue = null;
Func <object> right = () =>
{
if (rightValue == null)
{
binary.RightExpression.Accept(this);
rightValue = Result;
}
return(rightValue);
};
switch (binary.Type)
{
case BinaryExpressionType.And:
Result = ConversionUtility.Convert <bool>(left()) && ConversionUtility.Convert <bool>(right());
break;
case BinaryExpressionType.Or:
Result = ConversionUtility.Convert <bool>(left()) || ConversionUtility.Convert <bool>(right());
break;
case BinaryExpressionType.Div:
Result = OperatorUtility.Divide(left(), right());
break;
case BinaryExpressionType.Equal:
Result = OperatorUtility.Equal(left(), right());
break;
case BinaryExpressionType.Greater:
Result = OperatorUtility.GreaterThan(left(), right());
break;
case BinaryExpressionType.GreaterOrEqual:
Result = OperatorUtility.GreaterThanOrEqual(left(), right());
break;
case BinaryExpressionType.Lesser:
Result = OperatorUtility.LessThan(left(), right());
break;
case BinaryExpressionType.LesserOrEqual:
Result = OperatorUtility.LessThanOrEqual(left(), right());
break;
case BinaryExpressionType.Minus:
Result = OperatorUtility.Subtract(left(), right());
break;
case BinaryExpressionType.Modulo:
Result = OperatorUtility.Modulo(left(), right());
break;
case BinaryExpressionType.NotEqual:
Result = OperatorUtility.NotEqual(left(), right());
break;
case BinaryExpressionType.Plus:
Result = OperatorUtility.Add(left(), right());
break;
case BinaryExpressionType.Times:
Result = OperatorUtility.Multiply(left(), right());
break;
case BinaryExpressionType.BitwiseAnd:
Result = OperatorUtility.And(left(), right());
break;
case BinaryExpressionType.BitwiseOr:
Result = OperatorUtility.Or(left(), right());
break;
case BinaryExpressionType.BitwiseXOr:
Result = OperatorUtility.ExclusiveOr(left(), right());
break;
case BinaryExpressionType.LeftShift:
Result = OperatorUtility.LeftShift(left(), right());
break;
case BinaryExpressionType.RightShift:
Result = OperatorUtility.RightShift(left(), right());
break;
}
}
protected override bool ShouldTrigger(Flow flow, EmptyEventArgs args)
{
var data = flow.stack.GetElementData <Data>(this);
if (!data.isListening)
{
return(false);
}
var name = flow.GetValue <string>(this.name);
VariableDeclarations variables;
switch (kind)
{
case VariableKind.Flow:
variables = flow.variables;
break;
case VariableKind.Graph:
variables = Variables.Graph(flow.stack);
break;
case VariableKind.Object:
variables = Variables.Object(flow.GetValue <GameObject>(@object));
break;
case VariableKind.Scene:
variables = Variables.Scene(flow.stack.scene);
break;
case VariableKind.Application:
variables = Variables.Application;
break;
case VariableKind.Saved:
variables = Variables.Saved;
break;
default:
throw new UnexpectedEnumValueException <VariableKind>(kind);
}
var val = variables.Get(name);
if (data.firstExecution)
{
if (provideInitial)
{
data._previousValue = flow.GetValue <object>(Initial);
}
else
{
data._previousValue = val;
}
}
bool equal = OperatorUtility.Equal(data._previousValue, val);
if (!equal)
{
data._previousValue = val;
flow.SetValue(value, val);
}
data.firstExecution = false;
return(!equal);
}
protected override bool GenericComparison(object a, object b)
{
return(OperatorUtility.GreaterThanOrEqual(a, b));
}
