private void DoCalculation(IExecutionEnvironment environment, string fieldName, string cleanExpression, int update)
{
var functionEvaluator = new FunctionEvaluator();
var warewolfEvalResult = environment.Eval(cleanExpression, update);
if (warewolfEvalResult.IsWarewolfAtomResult)
{
var result = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult;
if (result != null)
{
var eval = PerformCalcForAtom(result.Item, functionEvaluator);
var doCalculation = new AssignValue(fieldName, eval);
environment.AssignWithFrame(doCalculation, update);
}
}
if (warewolfEvalResult.IsWarewolfAtomListresult)
{
var result = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
if (result != null)
{
var counter = 1;
foreach (var item in result.Item)
{
var eval = PerformCalcForAtom(item, functionEvaluator);
var doCalculation = new AssignValue(fieldName, eval);
environment.AssignWithFrame(doCalculation, update == 0 ? counter : update);
counter++;
}
}
}
}
public List <SqlStringBuilder> GetUpdateStatements(object instance, Type type, Database db)
{
List <SqlStringBuilder> results = new List <SqlStringBuilder>();
db = db ?? Database;
SqlStringBuilder rootUpdate = db.GetService <SqlStringBuilder>();
Func <string, string> columnNameFormatter = rootUpdate.ColumnNameFormatter;
AssignValue uniqueness = GetUniquenessFilter(instance, columnNameFormatter);
TypeInheritanceDescriptor inheritance = new TypeInheritanceDescriptor(type);
Type rootType = inheritance.RootType;
rootUpdate.Update(Dao.TableName(rootType), GetBaseTypeAssignValues(rootType, instance, columnNameFormatter).ToArray()).Where(uniqueness);
results.Add(rootUpdate);
inheritance.Chain.BackwardsEach(typeTable =>
{
Type tableType = typeTable.Type;
if (tableType != rootType)
{
SqlStringBuilder inheritor = db.GetService <SqlStringBuilder>();
inheritor.Update(Dao.TableName(tableType), GetInheritingTypeAssignValues(tableType, instance, columnNameFormatter).ToArray()).Where(uniqueness);
inheritor.Go();
results.Add(inheritor);
}
});
return(results);
}
void AddTableToDataList(Table table)
{
// build up DataTable
foreach (TableRow row in table.Rows)
{
var i = 0;
foreach (string columnName in table.Header)
{
var value = row[i] == "blank" ? "" : row[i];
if (value.ToUpper() == "NULL")
{
var recordsetDisplayValue = DataListUtil.CreateRecordsetDisplayValue("rs", columnName, "");
DataObject.Environment.AssignDataShape(DataListUtil.AddBracketsToValueIfNotExist(recordsetDisplayValue));
}
else
{
var recordsetDisplayValue = DataListUtil.CreateRecordsetDisplayValue("rs", columnName, "");
var assignValue = new AssignValue(DataListUtil.AddBracketsToValueIfNotExist(recordsetDisplayValue), row[i]);
DataObject.Environment.AssignWithFrame(assignValue, 0);
}
i++;
}
DataObject.Environment.CommitAssign();
}
// Execute Translator
}
protected internal override AssignValue GetAssignment(string keyColumn, object value, Func <string, string> columnNameformatter = null)
{
AssignValue result = base.GetAssignment(keyColumn, value, columnNameformatter);
result.ParameterPrefix = ":";
return(result);
}
public void Execute(AssignValue cmd)
{
switch (cmd.Recipient.Type)
{
case Type.Entero:
cmd.Recipient.Value = (int)cmd.Value;
break;
case Type.Decimal:
cmd.Recipient.Value = (double)cmd.Value;
break;
case Type.Booleano:
cmd.Recipient.Value = (bool)cmd.Value;
break;
case Type.Cadena:
cmd.Recipient.Value = (string)cmd.Value;
break;
default:
cmd.Recipient.Value = cmd.Value;
break;
}
}
public void GivenEmptyString_ExecutionEnvironmentAssignJson_ShouldReturn()
{
Assert.IsNotNull(_environment);
var values = new AssignValue(string.Empty, "John");
_environment.AssignJson(values, 0);
}
public void GivenInvalidObject_ExecutionEnvironmentAssignJson_ShouldThrowParseError()
{
Assert.IsNotNull(_environment);
var values = new AssignValue("[[@Person.Name]", "John");
_environment.AssignJson(values, 0);
Assert.AreEqual(1, _environment.Errors.Count);
}
public static WhereFormat GetWhereFormat(AssignValue filter, StringBuilder stringBuilder, int?startNumber)
{
WhereFormat where = new WhereFormat();
where.ColumnNameFormatter = (c) => c;
where.ParameterPrefix = "@";
where.StartNumber = startNumber;
where.AddAssignment(filter);
stringBuilder.Append(where.Parse());
return(where);
}
private AssignValue AddDebugOutputItem(IDSFDataObject dataObject, int update, int innerCount, AssignValue assignValue)
{
if (DataListUtil.IsValueRecordset(assignValue.Name) && DataListUtil.GetRecordsetIndexType(assignValue.Name) == enRecordsetIndexType.Blank)
{
var length = dataObject.Environment.GetObjectLength(DataListUtil.ExtractRecordsetNameFromValue(assignValue.Name));
assignValue = new AssignValue(DataListUtil.ReplaceObjectBlankWithIndex(assignValue.Name, length), assignValue.Value);
}
AddSingleDebugOutputItem(dataObject.Environment, innerCount, assignValue, update);
return(assignValue);
}
/// <summary>
/// Executes a CallFunction command
/// </summary>
/// <param name="cmd">command to be executed.</param>
public void Execute(CallFunction cmd)
{
var commands = cmd.Function.CommandList;
if (commands == null)
{
return;
}
// Remove and save previous assign value commands
var stack = new Stack <AssignValue>();
while (commands.Commands[1] is AssignValue)
{
stack.Push((AssignValue)commands.Commands[1]);
commands.Commands.RemoveAt(1);
}
// Add my assign value commands.
for (var para = cmd.Parameters.Count - 1; para >= 0; para--)
{
var parameter = cmd.Function.Parameters[para];
var newCmd = new AssignValue
{
Recipient = parameter,
Value = cmd.Parameters[para].Value
};
commands.Commands.Insert(1, newCmd);
}
Execute(commands);
// Remove my assign value commands
for (var para = cmd.Parameters.Count - 1; para >= 0; para--)
{
commands.Commands.RemoveAt(1);
}
// Restore previous assign value commands.
while (stack.Count != 0)
{
commands.Commands.Insert(1, stack.Pop());
}
// Manages the return value.
if (cmd.Function.Type != Type.Rutina)
{
var aux = cmd.Function.Returns.Value;
if (!(cmd.Function.Returns is Constant))
{
cmd.Function.Returns.Unroll();
}
cmd.Result.Value = aux;
}
}
public static void TargetAddressTest(int initValue, string targetOwnerId,
bool isError, int answerValue)
{
var instance = new AssignValue
{
Owner = targetOwnerId.Equals("m")
? TargetAddressOwner.MapEvent
: TargetAddressOwner.CommonEvent
};
var changedPropertyList = new List <string>();
instance.PropertyChanged += (sender, args) => { changedPropertyList.Add(args.PropertyName); };
var errorOccured = false;
try
{
instance.TargetAddress = initValue;
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーフラグが一致すること
Assert.AreEqual(errorOccured, isError);
if (!errorOccured)
{
var resultValue = (int)instance.TargetAddress;
// 取得した値が意図した値と一致すること
Assert.AreEqual(resultValue, answerValue);
}
// 意図したとおりプロパティ変更通知が発火していること
if (errorOccured)
{
Assert.AreEqual(changedPropertyList.Count, 0);
}
else
{
Assert.AreEqual(changedPropertyList.Count, 1);
Assert.IsTrue(changedPropertyList[0].Equals(nameof(AssignValue.TargetAddress)));
}
}
public static void CharaMoveCommandOwnerTest()
{
var assignValue = new AssignValue();
var assignValue2 = new AssignValue();
var addValue = new AddValue();
var addValue2 = new AddValue();
// この時点で EventCommand の Owner が null であることを確認
Assert.IsNull(assignValue.Owner);
Assert.IsNull(assignValue2.Owner);
Assert.IsNull(addValue.Owner);
Assert.IsNull(addValue2.Owner);
var actionEntry = new ActionEntry();
actionEntry.CommandList.Add(assignValue);
actionEntry.CommandList.Add(addValue);
// この時点で ActionEntry, EventCommand の Owner が null であることを確認
Assert.IsNull(actionEntry.Owner);
Assert.IsNull(assignValue.Owner);
Assert.IsNull(assignValue2.Owner);
Assert.IsNull(addValue.Owner);
Assert.IsNull(addValue2.Owner);
var instance = new MapEventPageMoveRouteInfo
{
CustomMoveRoute = actionEntry
};
// この時点で ActionEntry, セット済みのEventCommand の Owner がセットされていることを確認
Assert.AreEqual(actionEntry.Owner, TargetAddressOwner.MapEvent);
Assert.AreEqual(assignValue.Owner, TargetAddressOwner.MapEvent);
Assert.AreEqual(addValue.Owner, TargetAddressOwner.MapEvent);
Assert.IsNull(assignValue2.Owner);
Assert.IsNull(addValue2.Owner);
actionEntry.CommandList.Add(assignValue2);
actionEntry.CommandList.Add(addValue2);
// EventCommand の Owner に適切な値が設定されること
Assert.AreEqual(assignValue2.Owner, TargetAddressOwner.MapEvent);
Assert.AreEqual(addValue2.Owner, TargetAddressOwner.MapEvent);
// instance をここまで開放したくないので無駄な処理を入れる
instance.MoveSpeed = MoveSpeed.Fast;
}
private void AddTableToDataList(Table table)
{
// build up DataTable
foreach (TableRow row in table.Rows)
{
var i = 0;
foreach (string columnName in table.Header)
{
var recordsetDisplayValue = DataListUtil.CreateRecordsetDisplayValue("rs", columnName, "");
var assignValue = new AssignValue(DataListUtil.AddBracketsToValueIfNotExist(recordsetDisplayValue), row[i]);
DataObject.Environment.AssignWithFrame(assignValue, 0);
i++;
}
DataObject.Environment.CommitAssign();
}
// Execute Translator
}
void ExecuteField(IDSFDataObject dataObject, int update, int innerCount, ActivityDTO t, ErrorResultTO allErrors)
{
var assignValue = new AssignValue(t.FieldName, t.FieldValue);
var isCalcEvaluation = DataListUtil.IsCalcEvaluation(t.FieldValue, out string cleanExpression);
if (isCalcEvaluation)
{
assignValue = new AssignValue(t.FieldName, cleanExpression);
}
DebugItem debugItem = null;
if (dataObject.IsDebugMode())
{
debugItem = TryCreateDebugInput(dataObject.Environment, innerCount, assignValue, update);
}
try
{
if (isCalcEvaluation)
{
DoCalculation(dataObject.Environment, t.FieldName, t.FieldValue, update);
}
else
{
dataObject.Environment.AssignWithFrame(assignValue, update);
}
} catch (Exception e)
{
Dev2Logger.Error(nameof(DsfMultiAssignActivity), e, GlobalConstants.WarewolfError);
allErrors.AddError(e.Message);
}
if (debugItem != null)
{
_debugInputs.Add(debugItem);
}
if (dataObject.IsDebugMode())
{
if (DataListUtil.IsValueRecordset(assignValue.Name) && DataListUtil.GetRecordsetIndexType(assignValue.Name) == enRecordsetIndexType.Blank)
{
var length = dataObject.Environment.GetLength(DataListUtil.ExtractRecordsetNameFromValue(assignValue.Name));
assignValue = new AssignValue(DataListUtil.ReplaceRecordsetBlankWithIndex(assignValue.Name, length), assignValue.Value);
}
AddSingleDebugOutputItem(dataObject.Environment, innerCount, assignValue, update);
}
}
private void AssignField(IDSFDataObject dataObject, int update, int innerCount, ActivityDTO t, ErrorResultTO allErrors)
{
var assignValue = new AssignValue(t.FieldName, t.FieldValue);
var isCalcEvaluation = DataListUtil.IsCalcEvaluation(t.FieldValue, out string cleanExpression);
if (isCalcEvaluation)
{
assignValue = new AssignValue(t.FieldName, cleanExpression);
}
DebugItem debugItem = null;
if (dataObject.IsDebugMode())
{
debugItem = AddSingleInputDebugItem(dataObject.Environment, innerCount, assignValue, update);
}
try
{
if (isCalcEvaluation)
{
DoCalculation(dataObject.Environment, t.FieldName, t.FieldValue, update);
}
else
{
dataObject.Environment.AssignWithFrame(assignValue, update);
}
} catch (Exception e)
{
allErrors.AddError(e.Message);
}
if (debugItem != null)
{
_debugInputs.Add(debugItem);
}
if (dataObject.IsDebugMode())
{
if (DataListUtil.IsValueRecordset(assignValue.Name) && DataListUtil.GetRecordsetIndexType(assignValue.Name) == enRecordsetIndexType.Blank && !assignValue.Name.Contains(DataListUtil.ObjectStartMarker))
{
var length = dataObject.Environment.GetLength(DataListUtil.ExtractRecordsetNameFromValue(assignValue.Name));
assignValue = new AssignValue(DataListUtil.ReplaceRecordsetBlankWithIndex(assignValue.Name, length), assignValue.Value);
}
AddSingleDebugOutputItem(dataObject.Environment, innerCount, assignValue, update);
}
}
public static void SerializeTest()
{
var target = new AssignValue
{
Value = 21,
Owner = TargetAddressOwner.CommonEvent
};
var changedPropertyList = new List <string>();
target.PropertyChanged += (sender, args) => { changedPropertyList.Add(args.PropertyName); };
var clone = DeepCloner.DeepClone(target);
Assert.IsTrue(clone.Equals(target));
// プロパティ変更通知が発火していないこと
Assert.AreEqual(changedPropertyList.Count, 0);
}
void TryExecuteField(IDSFDataObject dataObject, int update, ErrorResultTO allErrors, int innerCount, AssignObjectDTO t)
{
try
{
if (!string.IsNullOrEmpty(t.FieldName))
{
var assignValue = new AssignValue(t.FieldName, t.FieldValue);
var isCalcEvaluation = DataListUtil.IsCalcEvaluation(t.FieldValue, out string cleanExpression);
if (isCalcEvaluation)
{
assignValue = new AssignValue(t.FieldName, cleanExpression);
}
DebugItem debugItem = null;
if (dataObject.IsDebugMode())
{
debugItem = AddSingleInputDebugItem(dataObject.Environment, innerCount, assignValue, update);
}
if (isCalcEvaluation)
{
DoCalculation(dataObject.Environment, t.FieldName, t.FieldValue, update);
}
else
{
dataObject.Environment.AssignJson(assignValue, update);
}
if (debugItem != null)
{
_debugInputs.Add(debugItem);
}
if (dataObject.IsDebugMode())
{
assignValue = AddDebugOutputItem(dataObject, update, innerCount, assignValue);
}
}
}
catch (Exception e)
{
//Dev2Logger.Error(nameof(DsfMultiAssignObjectActivity), e, GlobalConstants.WarewolfError);
allErrors.AddError(e.Message);
}
}
private int AssignField(IDSFDataObject dataObject, int update, int innerCount, AssignObjectDTO t)
{
if (!string.IsNullOrEmpty(t.FieldName))
{
var assignValue = new AssignValue(t.FieldName, t.FieldValue);
var isCalcEvaluation = DataListUtil.IsCalcEvaluation(t.FieldValue, out string cleanExpression);
if (isCalcEvaluation)
{
assignValue = new AssignValue(t.FieldName, cleanExpression);
}
DebugItem debugItem = null;
if (dataObject.IsDebugMode())
{
debugItem = AddSingleInputDebugItem(dataObject.Environment, innerCount, assignValue, update);
}
if (isCalcEvaluation)
{
DoCalculation(dataObject.Environment, t.FieldName, t.FieldValue, update);
}
else
{
dataObject.Environment.AssignJson(assignValue, update);
}
if (debugItem != null)
{
_debugInputs.Add(debugItem);
}
if (dataObject.IsDebugMode())
{
if (DataListUtil.IsValueRecordset(assignValue.Name) && DataListUtil.GetRecordsetIndexType(assignValue.Name) == enRecordsetIndexType.Blank)
{
var length = dataObject.Environment.GetObjectLength(DataListUtil.ExtractRecordsetNameFromValue(assignValue.Name));
assignValue = new AssignValue(DataListUtil.ReplaceObjectBlankWithIndex(assignValue.Name, length), assignValue.Value);
}
AddSingleDebugOutputItem(dataObject.Environment, innerCount, assignValue, update);
}
}
innerCount++;
return(innerCount);
}
void DoCalculation(IExecutionEnvironment environment, string fieldName, string cleanExpression, int update)
{
var functionEvaluator = new FunctionEvaluator(FunctionEvaluatorOption.DotNetDateTimeFormat);
var warewolfEvalResult = environment.Eval(cleanExpression, update);
if (warewolfEvalResult.IsWarewolfAtomResult && warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult atomResult)
{
var eval = PerformCalcForAtom(atomResult.Item, functionEvaluator);
var doCalculation = new AssignValue(fieldName, eval);
environment.AssignWithFrame(doCalculation, update);
}
if (warewolfEvalResult.IsWarewolfAtomListresult && warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult atomListResult)
{
var counter = 1;
foreach (var item in atomListResult.Item)
{
var eval = PerformCalcForAtom(item, functionEvaluator);
var doCalculation = new AssignValue(fieldName, eval);
environment.AssignWithFrame(doCalculation, update == 0 ? counter : update);
counter++;
}
}
}
void ExecuteField(IDSFDataObject dataObject, int update, int innerCount, ActivityDTO t)
{
var assignValue = new AssignValue(t.FieldName, t.FieldValue);
var isCalcEvaluation = DataListUtil.IsCalcEvaluation(t.FieldValue, out string cleanExpression);
if (isCalcEvaluation)
{
assignValue = new AssignValue(t.FieldName, cleanExpression);
}
DebugItem debugItem = null;
if (dataObject.IsDebugMode())
{
debugItem = TryCreateDebugInput(dataObject.Environment, innerCount, assignValue, update);
}
if (isCalcEvaluation)
{
DoCalculation(dataObject.Environment, t.FieldName, t.FieldValue, update);
}
else
{
dataObject.Environment.AssignWithFrame(assignValue, update);
}
if (debugItem != null)
{
_debugInputs.Add(debugItem);
}
if (dataObject.IsDebugMode())
{
if (DataListUtil.IsValueRecordset(assignValue.Name) && DataListUtil.GetRecordsetIndexType(assignValue.Name) == enRecordsetIndexType.Blank)
{
var length = dataObject.Environment.GetLength(DataListUtil.ExtractRecordsetNameFromValue(assignValue.Name));
assignValue = new AssignValue(DataListUtil.ReplaceRecordsetBlankWithIndex(assignValue.Name, length), assignValue.Value);
}
AddSingleDebugOutputItem(dataObject.Environment, innerCount, assignValue, update);
}
}
public string ValueToCS()
{
return(Is.Replace(str, "${AssignmentStatement_Varible} = " + AssignValue.ValueToCS()));
}
public static void EventCommandsOwnerTest()
{
var assignValue = new AssignValue();
var assignValue2 = new AssignValue();
var addValue = new AddValue();
var addValue2 = new AddValue();
// この時点で EventCommand の Owner が null であることを確認
Assert.IsNull(assignValue.Owner);
Assert.IsNull(assignValue2.Owner);
Assert.IsNull(addValue.Owner);
Assert.IsNull(addValue2.Owner);
var commonEvent = new CommonEvent();
var list = new EventCommandList();
var moveRoute = new MoveRoute();
var actionEntry = new ActionEntry();
actionEntry.CommandList.Add(assignValue);
actionEntry.CommandList.Add(addValue);
// この時点で EventCommandList, MoveRoute, ActionEntry, EventCommand の Owner が null であることを確認
Assert.IsNull(list.Owner);
Assert.IsNull(moveRoute.Owner);
Assert.IsNull(actionEntry.Owner);
Assert.IsNull(assignValue.Owner);
Assert.IsNull(assignValue2.Owner);
Assert.IsNull(addValue.Owner);
Assert.IsNull(addValue2.Owner);
moveRoute.ActionEntry = actionEntry;
list.Add(moveRoute);
// この時点で EventCommand の Owner が null であることを確認
Assert.IsNull(assignValue.Owner);
Assert.IsNull(assignValue2.Owner);
Assert.IsNull(addValue.Owner);
Assert.IsNull(addValue2.Owner);
commonEvent.EventCommands = list;
// この時点で EventCommandList, MoveRoute, ActionEntry, セット済みのEventCommand の
// Owner がセットされていることを確認
Assert.AreEqual(list.Owner, TargetAddressOwner.CommonEvent);
Assert.AreEqual(moveRoute.Owner, TargetAddressOwner.CommonEvent);
Assert.AreEqual(assignValue.Owner, TargetAddressOwner.CommonEvent);
Assert.AreEqual(addValue.Owner, TargetAddressOwner.CommonEvent);
actionEntry.CommandList.Add(assignValue2);
moveRoute.ActionEntry.CommandList.Add(addValue2);
// EventCommand の Owner に適切な値が設定されること
Assert.AreEqual(assignValue2.Owner, TargetAddressOwner.CommonEvent);
Assert.AreEqual(addValue2.Owner, TargetAddressOwner.CommonEvent);
// commonEvent をここまで開放したくないので無駄な処理を入れる
commonEvent.Memo = "";
}
public void Execute(AssignValue assignValue)
{
_file.WriteLine($"{_indents}AssignValue\tValue:{assignValue.Value.Name},Recipient:{assignValue.Recipient.Name}");
}
// Performs actions defined by the Node
// If the Node is part of core functionality of the language, e.g. assigning to variables, performing arithmetic, etc. then handle it here.
// Otherwise, continue to child implementations of this method.
public virtual ExecutionStatus ExecuteNode(NodeBase node)
{
if (node == null)
{
programRunning = false;
currentNode = program.programStart;
return(new ExecutionStatus {
success = false, handover = false
});
}
switch (CheckNodeType(node))
{
// Handlers for different commands
case NodeType.ProgramStart:
Logger.Log("Program starting!");
processingDone = true;
InitSymTable();
// TODO: this doesn't actually reset the buffer?
outputBuffer = "";
return(new ExecutionStatus {
success = true, handover = false
});
case NodeType.AssignValue:
AssignValue assignValue = node.GetComponent <AssignValue>();
SetSymbol(assignValue.leftHand, assignValue.rightHand);
return(new ExecutionStatus {
success = true, handover = false
});
case NodeType.ArithmeticOperationBase:
// Arithmetic only takes a tick when it gets executed
currentNode = (NodeBase)currentNode.nextNode;
return(ExecuteNode(currentNode));
case NodeType.ProgramEnd:
processingDone = true;
programRunning = false;
return(new ExecutionStatus {
success = true, handover = false
});
case NodeType.FunctionCallBase:
string funcName = node.GetComponent <FunctionCallBase>().functionName;
if (BaseControllerFunctions().ContainsKey(funcName))
{
// TODO: passing a copy of symbolTable here might consume too much memory. Make static?
functions[funcName].DynamicInvoke(node.GetComponent <FunctionCallBase>().GetRawParameters(symbolTable));
Logger.Log($"Found base function {funcName}");
return(new ExecutionStatus {
success = true, handover = false
});
}
Logger.Log($"Couldn't find base function {funcName}");
break;
case NodeType.LogicalBlock:
case NodeType.WhileLoop:
case NodeType.ElseBlock:
// Make sure all nodes in the block body have their ownerLoop assigned
node.GetComponent <LogicalBlock>().PropagateOwnership();
if (DistanceCheck())
{
GameObject.Find("OutputRenderer").transform.Find("Canvas").GetComponentInChildren <Text>().text = ((CodeBlock)currentNode).SerializeBlockHeader();
}
//new WaitForSeconds((float)tickTime
bool evaluatedResult = false;
// ElseBlocks should activate when its associated LogicalBlocks evaluate as false.
if (node.GetComponent <ElseBlock>())
{
if (node.PrevNodeObject.GetComponent <LogicalBlock>() && !node.PrevNodeObject.GetComponent <ElseBlock>() && !node.PrevNodeObject.GetComponent <WhileLoop>())
{
evaluatedResult = !node.PrevNodeObject.GetComponent <LogicalBlock>().evaluatedResult;
}
}
else
{
evaluatedResult = node.GetComponent <LogicalBlock>().condition.Evaluate(ref symbolTable);
}
node.GetComponent <LogicalBlock>().evaluatedResult = evaluatedResult;
if (evaluatedResult && ((!node.GetComponent <WhileLoop>()) || (node.GetComponent <WhileLoop>() && !node.GetComponent <WhileLoop>().breakNow)))
{
NodeBase nodeToFollow = (NodeBase)(node.GetComponent <LogicalBlock>().firstBodyNode);
if (nodeToFollow != null)
{
specialNextNode = nodeToFollow;
}
else
{
specialNextNode = (NodeBase)currentNode.nextNode;
}
//return ExecuteNode(currentNode);
timeSinceTick = -tickTime;
return(new ExecutionStatus {
success = true, handover = false
});
}
break;
case NodeType.AllocateArray:
if (node.GetComponent <AllocateArray>())
{
int count = -1;
// Check if entered size was a valid >= 0 integer.
// TODO: unexpected behaviour when allocating with size == 0
Logger.Log($"Allocating array with count {(string)node.GetComponent<AllocateArray>().GetRawParameters(symbolTable)[0]}");
if (int.TryParse((string)node.GetComponent <AllocateArray>().GetRawParameters(symbolTable)[0], out count))
{
string arrName = node.GetComponent <AllocateArray>().parameters[1].Value;
if (string.IsNullOrWhiteSpace(arrName))
{
// TODO: error too?
return(new ExecutionStatus {
success = false, handover = false
});
}
for (int i = 0; i < count; i++)
{
Logger.Log($"Adding array element \"{arrName}[{i}]\"");
symbolTable.Add($"{arrName}[{i}]", new FunctionParameter {
Value = "None"
});
}
// Only initialise elements in the symbol table if size was provided as a literal
if (int.TryParse(node.GetComponent <AllocateArray>().parameters[0].Value, out count))
{
for (int i = 2; i < 2 + count; i++)
{
FunctionParameter listElement = node.GetComponent <AllocateArray>().parameters[i];
SetSymbol(new FunctionParameter {
Value = listElement.Name
}, new FunctionParameter {
Value = string.IsNullOrWhiteSpace(listElement.Value) ? "None" : listElement.Value
});
}
}
return(new ExecutionStatus {
success = true, handover = false
});
}
}
break;
case NodeType.Continue:
if (node.GetComponent <Continue>())
{
// Find the while loop
LogicalBlock owner = node.ownerLoop;
while (owner != null)
{
WhileLoop loop = owner.GetComponent <WhileLoop>();
if (loop != null)
{
currentNode = loop;
return(ExecuteNode(currentNode));
}
else
{
owner = owner.ownerLoop;
}
}
if (owner == null)
{
return(new ExecutionStatus {
success = false, handover = false
});
}
}
break;
case NodeType.Break:
if (node.GetComponent <Break>())
{
// Find the while loop
LogicalBlock owner = node.ownerLoop;
while (owner != null)
{
WhileLoop loop = owner.GetComponent <WhileLoop>();
if (loop != null)
{
loop.breakNow = true;
currentNode = loop;
return(ExecuteNode(currentNode));
}
else
{
owner = owner.ownerLoop;
}
}
if (owner == null)
{
return(new ExecutionStatus {
success = false, handover = false
});
}
}
break;
}
return(new ExecutionStatus {
success = true, handover = true
});
}
//public override IDev2Activity Execute(IDSFDataObject data)
//{
// ExecuteTool(data);
// if(NextNodes != null && NextNodes.Count()>0)
// {
// NextNodes.First().Execute(data);
// return NextNodes.First();
// }
// return null;
//}
#endregion
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
_debugOutputs.Clear();
_debugInputs.Clear();
InitializeDebug(dataObject);
ErrorResultTO errors = new ErrorResultTO();
ErrorResultTO allErrors = new ErrorResultTO();
try
{
if (!errors.HasErrors())
{
int innerCount = 1;
foreach (ActivityDTO t in FieldsCollection)
{
try
{
if (!string.IsNullOrEmpty(t.FieldName))
{
string cleanExpression;
var assignValue = new AssignValue(t.FieldName, t.FieldValue);
var isCalcEvaluation = DataListUtil.IsCalcEvaluation(t.FieldValue, out cleanExpression);
if (isCalcEvaluation)
{
assignValue = new AssignValue(t.FieldName, cleanExpression);
}
DebugItem debugItem = null;
if (dataObject.IsDebugMode())
{
debugItem = AddSingleInputDebugItem(dataObject.Environment, innerCount, assignValue, update);
}
if (isCalcEvaluation)
{
DoCalculation(dataObject.Environment, t.FieldName, t.FieldValue, update);
}
else
{
dataObject.Environment.AssignWithFrame(assignValue, update);
}
if (debugItem != null)
{
_debugInputs.Add(debugItem);
}
if (dataObject.IsDebugMode())
{
if (DataListUtil.IsValueRecordset(assignValue.Name) && DataListUtil.GetRecordsetIndexType(assignValue.Name) == enRecordsetIndexType.Blank)
{
var length = dataObject.Environment.GetLength(DataListUtil.ExtractRecordsetNameFromValue(assignValue.Name));
assignValue = new AssignValue(DataListUtil.ReplaceRecordsetBlankWithIndex(assignValue.Name, length), assignValue.Value);
}
AddSingleDebugOutputItem(dataObject.Environment, innerCount, assignValue, update);
}
}
innerCount++;
}
catch (Exception e)
{
Dev2Logger.Error(e);
allErrors.AddError(e.Message);
}
}
dataObject.Environment.CommitAssign();
allErrors.MergeErrors(errors);
}
}
catch (Exception e)
{
Dev2Logger.Error(e);
allErrors.AddError(e.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfAssignActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
