public override void ConvertElementLogic()
{
var attachedToConverter = processConverter.GetConverterOfElementOfType <TaskConverter>(eventElement.AttachedTo);
touchFunction = CreateTouchFunction(attachedToConverter);
AddTouchCheckToAttachedElement(attachedToConverter);
}
SolidityFunction CreateElementMainFunction(ElementConverter nextElement, List <SolidityStruct> dataModel)
{
SolidityFunction function = new SolidityFunction(GetTaskName(), SolidityVisibility.Public);
function.AddModifier("is" + GetTaskName() + "State");
if (userTask.Assignee != null && (userTask.Assignee.Address != null || userTask.Assignee.Name != null))
{
function.AddModifier("is" + GetTaskName() + "Authorized");
}
SolidityStatement statement = new SolidityStatement(ProcessConverter.ACTIVE_STATES_NAME + "[\"" + GetTaskName() + "\"] = false");
function.AddToBody(statement);
if (userTask.Form.Fields != null)
{
foreach (var field in userTask.Form.Fields)
{
foreach (var s in dataModel)
{
Property p = s.En.Properties.FirstOrDefault(p => p.Id == field.PropertyExpression);
if (p != null)
{
function.AddParameter(new SolidityParameter(Helpers.GetSolidityStringType(p), field.DisplayName));
function.AddToBody(new SolidityStatement(s.VariableName() + "." + Helpers.GetPropertyVariableName(p.Name) + " = " + field.DisplayName));
}
}
}
}
function.AddToBody(nextElement.GetStatementForPrevious(userTask));
return(function);
}
public override SolidityFunction CreateDecisionFunction()
{
FunctionName = Regex.Replace(Decision.Id, @" ", "").ToLowerCamelCase();
SolidityFunction function = new SolidityFunction(FunctionName, SolidityVisibility.Internal, $"{OutputStructName} memory", true);
//Add declaration of helper varaibles
function.AddToBody(new SolidityStatement($"{OutputStructName} memory output", true));
function.AddToBody(new SolidityStatement($"bool matchedRule = false", true));
//Add checks of conditions for matches and their bodies
var rules = GetAllConditions();
foreach (var rule in rules.Select((value, i) => new { i, value }))
{
var conditionCheck = GetConditionCheck(rule.i);
function.AddToBody(AddBodyBasedOnRule(rule.value, conditionCheck.ToString()));
}
//Add the rest of the function
var undefinedOutputCheck = new SolidityIfElse();
undefinedOutputCheck.AddConditionBlock("!matchedRule", new SolidityStatement("revert('Undefined output')", true));
function.AddToBody(undefinedOutputCheck);
function.AddToBody(new SolidityStatement("return output", true));
return(function);
}
public override void ConvertElementLogic()
{
processReturnFunction = CreateProcessReturnFunction();
mainFunction = new SolidityFunction(GetElementCallName(), SolidityVisibility.Internal);
mainFunction.AddParameters(processConverter.GetIdentifiersAsParameters());
var calledStartEventConverter = processConverter.ContractConverter.GetStartEventConverter(callActivity);
var callSubprocessStatement = calledStartEventConverter.GetStatementForPrevious(callActivity);
stateTracker = new SolidityStatement($"uint256 {ConversionTemplates.CallActivityCounter(GetElementCallName())}");
switch (callActivity.InstanceType)
{
case InstanceType.Single:
//Call the subprocess.
mainFunction.AddToBody(callSubprocessStatement);
break;
case InstanceType.Sequential:
//Call the subprocess and create a counter.
mainFunction.AddToBody(new SolidityStatement($"{ConversionTemplates.CallActivityCounter(GetElementCallName())} = 0"));
mainFunction.AddToBody(callSubprocessStatement);
break;
case InstanceType.Parallel:
//Call all of the subprocesses using an identifier, create a counter.
mainFunction.AddToBody(new SolidityStatement($"{ConversionTemplates.CallActivityCounter(GetElementCallName())} = 0"));
var solidityForLoop = new SolidityFor(GetLoopVariable(), GetCountTarget(callActivity));
solidityForLoop.AddToBody(callSubprocessStatement);
mainFunction.AddToBody(solidityForLoop);
break;
}
}
SolidityFunction CreateElementMainFunction()
{
SolidityFunction function = new SolidityFunction(GetElementCallName(), SolidityVisibility.Public);
function.AddModifier($"{ConversionTemplates.StateGuardModifierName(GetElementCallName())}({processConverter.GetIdentifierNames()})");
function.AddParameters(processConverter.GetIdentifiersAsParameters());
/*
* if (IsAddressGuardRequired())
* function.AddModifier($"{ConversionTemplates.AddressGuardModifierName(GetElementCallName())}({processConverter.GetIdentifierNames()})");
*/
boundaryEventCalls.ForEach(c => function.AddToBody(c));
function.AddToBody(new SolidityStatement(userTaskElement.ValidationScript, false));
if (userTaskElement.Form.Fields != null)
{
foreach (var field in userTaskElement.Form.Fields)
{
//TODO: throw exception if no property has been found
var propertyAndEntity = processConverter.GetPropertyAndEntity(field.PropertyExpression);
var property = propertyAndEntity.Item1;
var entity = propertyAndEntity.Item2;
var formPropertyDisplayName = Helpers.ToLowerCamelCase(field.DisplayName);
function.AddParameter(new SolidityParameter(Helpers.PropertyTypeToString(property, processConverter.ContractConverter), formPropertyDisplayName));
}
}
function.AddToBody(CreateCallNextBody());
return(function);
}
public override SolidityFunction CreateDecisionFunction()
{
//Define function's header
FunctionName = Regex.Replace(Decision.Id, @" ", "").ToLowerCamelCase();
SolidityFunction function = new SolidityFunction(FunctionName, SolidityVisibility.Internal, $"{OutputStructName} memory", true);
//Add declaration of helper varaibles
function.AddToBody(new SolidityStatement($"{OutputStructName} memory output", true));
function.AddToBody(new SolidityStatement($"bool matchedRule = false", true));
//For each row representing rule create condition for if statement
var rules = GetAllConditions();
foreach (var rule in rules.Select((value, i) => new { i, value }))
{
//Add to sum if the conditions are met
string conditionBody = string.Empty;
foreach (var outputEntry in Decision.DecisionTable.Rules[rule.i].OutputEntries.Select((value, i) => new { i, value }))
{
conditionBody += $"output.{Decision.DecisionTable.Outputs[outputEntry.i].Name.Replace(".", "__")} += {outputEntry.value.Text};\n";
}
conditionBody += "matchedRule = true;";
//If the row is empty then do not put the logic into conditional statement
function.AddToBody(AddBodyBasedOnRule(rule.value, conditionBody));
}
//Add the rest of the function
var undefinedOutputCheck = new SolidityIfElse();
undefinedOutputCheck.AddConditionBlock("!matchedRule", new SolidityStatement("revert('Undefined output')", true));
function.AddToBody(undefinedOutputCheck);
function.AddToBody(new SolidityStatement("return output", true));
return(function);
}
SolidityFunction CreateMainFunction()
{
var logicFunction = new SolidityFunction($"{GetElementCallName()}", SolidityVisibility.Internal);
var body = CreateCallsToOutgoing();
logicFunction.AddParameters(processConverter.GetIdentifiersAsParameters());
if (gatewayElement.Incoming.Count == 1)
{
logicFunction.AddToBody(body);
}
else
{
//Increment the incoming variable
logicFunction.AddToBody(new SolidityStatement($"{incrementVariableName} += 1"));
var ifElseBlock = new SolidityIfElse();
string ifElseCondition = $"{incrementVariableName}=={gatewayElement.Incoming.Count}";
//reset the incoming flow count
body.Add(incrementVariableName + " = 0");
ifElseBlock.AddConditionBlock(ifElseCondition, body);
logicFunction.AddToBody(ifElseBlock);
}
return(logicFunction);
}
public override SolidityFunction CreateDecisionFunction()
{
//Define function's header
FunctionName = Regex.Replace(Decision.Id, @" ", "").ToLowerCamelCase();
SolidityFunction function = new SolidityFunction(FunctionName, SolidityVisibility.Internal, $"{OutputStructName} memory", true);
//Add declaration of helper varaibles
function.AddToBody(new SolidityStatement($"{OutputStructName} memory output", true));
function.AddToBody(new SolidityStatement($"bool matchedRule = false", true));
//For each row representing rule create condition for if statement
var rules = GetAllConditions();
foreach (var rule in rules.Select((value, i) => new { i, value }))
{
var noMatchCheck = GetMatchOrNotBody(rule.i);
string conditionBody = noMatchCheck;
conditionBody += "matchedRule = true;";
function.AddToBody(AddBodyBasedOnRule(rule.value, conditionBody));
}
//Add the rest of the function
var undefinedOutputCheck = new SolidityIfElse();
undefinedOutputCheck.AddConditionBlock("!matchedRule", new SolidityStatement("revert('Undefined output')", true));
function.AddToBody(undefinedOutputCheck);
function.AddToBody(new SolidityStatement("return output", true));
return(function);
}
SolidityFunction CreateElementMainFunction()
{
SolidityFunction function = new SolidityFunction(GetElementCallName(), SolidityVisibility.Public);
function.AddModifier($"{ConversionTemplates.StateGuardModifierName(GetElementCallName())}({processConverter.GetIdentifierNames()})");
function.AddParameters(processConverter.GetIdentifiersAsParameters());
/*
* if (IsAddressGuardRequired())
* function.AddModifier($"{ConversionTemplates.AddressGuardModifierName(GetElementCallName())}({processConverter.GetIdentifierNames()})");
*/
boundaryEventCalls.ForEach(c => function.AddToBody(c));
function.AddToBody(new SolidityStatement(userTaskElement.ValidationScript, false));
foreach (var fieldGroup in userTaskElement.Form.FieldGroups)
{
foreach (var field in fieldGroup.Fields)
{
//var property = processConverter.GetProperty(field.ParamBind);
var formPropertyDisplayName = Helpers.ToLowerCamelCase(field.Label);
function.AddParameter(new SolidityParameter(Helpers.FormFieldToDataType(field), formPropertyDisplayName));
}
}
function.AddToBody(CreateCallNextBody());
return(function);
}
public override SolidityFunction CreateDecisionFunction()
{
FunctionName = Regex.Replace(Decision.Id, @" ", "").ToLowerCamelCase();
SolidityFunction function = new SolidityFunction(FunctionName, SolidityVisibility.Internal, $"{OutputStructName} memory", true);
//Add declaration of helper varaibles
var prioritiesFormatted = GetPriorities(Decision);
var noUniqueOutputs = Regex.Matches(prioritiesFormatted, $"{OutputStructName}").Count;
function.AddToBody(new SolidityStatement($"{OutputStructName}[{noUniqueOutputs}] memory priorities = {prioritiesFormatted}", true));
function.AddToBody(new SolidityStatement($"{OutputStructName} memory output", true));
function.AddToBody(new SolidityStatement($"bool matchedRule = false", true));
var rules = GetAllConditions();
foreach (var rule in rules.Skip(PriorityOffset).Select((value, i) => new { i, value }))
{
string priorityCheck = GetPriorityCheckBody(rule.i + PriorityOffset);
function.AddToBody(AddBodyBasedOnRule(rule.value, priorityCheck));
}
//Add the rest of the function
var undefinedOutputCheck = new SolidityIfElse();
undefinedOutputCheck.AddConditionBlock("!matchedRule", new SolidityStatement("revert('Undefined output')", true));
function.AddToBody(undefinedOutputCheck);
function.AddToBody(new SolidityStatement("return output", true));
return(function);
}
public override IList <SolidityComponent> GetElementCode(List <ElementConverter> nextElements, IList <SequenceFlow> outgoingSeqFlows, IList <SolidityStruct> dataModel = null)
{
var logicFunction = new SolidityFunction(gateway.Id + "Logic", SolidityVisibility.Internal);
var body = CreateParallelism(nextElements);
if (gateway.Incoming.Count == 1)
{
logicFunction.AddToBody(body);
return(new List <SolidityComponent> {
logicFunction
});
}
else
{
var incomingFlowsVar = new SolidityStatement("int " + incVaribaleName + " = 0");
var ifElseBlock = new SolidityIfElse();
string ifElseCondition = incVaribaleName + "==" + gateway.Incoming.Count.ToString();
body.Add(incVaribaleName + " = 0");
ifElseBlock.AddConditionBlock(ifElseCondition, body);
logicFunction.AddToBody(ifElseBlock);
return(new List <SolidityComponent> {
incomingFlowsVar, logicFunction
});
}
}
SolidityFunction CreateMintFunction()
{
SolidityFunction function = new SolidityFunction("mint", SolidityVisibility.Public);
function.AddParameter(new SolidityParameter("address", "receiver"));
function.AddModifier(ConverterConfig.OWNABLE_MODIFIER);
function.AddToBody(new SolidityStatement(token.MintScript, false));
//function.AddToBody(new SolidityStatement("_safeMint(receiver, uint256(receiver))"));
return(function);
}
SolidityFunction CreateTransferFunction()
{
SolidityFunction function = new SolidityFunction("transfer", SolidityVisibility.Public);
function.AddParameter(new SolidityParameter("address", "from"));
function.AddParameter(new SolidityParameter("address", "to"));
function.AddModifier(ConverterConfig.OWNABLE_MODIFIER);
function.AddToBody(new SolidityStatement(token.TransferScript, false));
return(function);
}
private SolidityFunction CreateTaskFunction()
{
SolidityFunction function = new SolidityFunction(GetElementCallName(), SolidityVisibility.Internal);
function.AddParameters(processConverter.GetIdentifiersAsParameters());
//Add the script logic
function.AddToBody(new SolidityStatement(scriptTaskElement.Script, false));
//Get the delegation logic of the next connected element
function.AddToBody(processConverter.GetStatementOfNextElement(scriptTaskElement));
return(function);
}
SolidityFunction CreateGetStateFunction()
{
var functionName = ConversionTemplates.ActiveStatesFunctionName(Id);
var getStateFunction = new SolidityFunction(functionName, SolidityVisibility.Public, "bool", true);
getStateFunction.AddToBody(new SolidityStatement($"return " +
$"{ConversionTemplates.ActiveStateAssignment(ConverterConfig.STATE_PARAMETER_NAME, Id, InstanceIdentifiers, true)}"));
//Add the potential process identifiers
getStateFunction.AddParameters(GetIdentifiersAsParameters());
getStateFunction.AddParameter(new SolidityParameter("string", ConverterConfig.STATE_PARAMETER_NAME));
return(getStateFunction);
}
public override void ConvertElementLogic()
{
/*
* if (IsAddressGuardRequired())
* addressGuard = CreateAddressGuard();
*/
stateGuard = CreateStateGuard();
mainFunction = CreateElementMainFunction();
if (userTaskElement.InstanceType != InstanceType.Single)
{
multiInstanceCounter = CreateMultiInstanceCounterDefinition();
}
}
public override IList <SolidityComponent> GetElementCode(List <ElementConverter> nextElements, IList <SequenceFlow> outgoingSeqFlows, IList <SolidityStruct> dataModel = null)
{
SolidityFunction function = new SolidityFunction(GetTaskName(), SolidityVisibility.Internal);
function.AddModifier("is" + GetTaskName() + "State");
SolidityStatement disableFunctionStatement = new SolidityStatement(ProcessConverter.ACTIVE_STATES_NAME + "[\"" + GetTaskName() + "\"] = false");
function.AddToBody(disableFunctionStatement);
function.AddToBody(new SolidityStatement(scriptTask.Script, false));
function.AddToBody(nextElements[0].GetStatementForPrevious(scriptTask));
return(new List <SolidityComponent> {
CreateStateGuard(), function
});
}
SolidityFunction CreateTouchFunction(TaskConverter attachedToConverter)
{
var function = new SolidityFunction($"touch{GetElementCallName()}", SolidityVisibility.Public, "bool");
function.AddParameters(processConverter.GetIdentifiersAsParameters());
function.AddModifier($"{ConversionTemplates.StateGuardModifierName(attachedToConverter.GetElementCallName())}({processConverter.GetIdentifierNames()})");
var solidityCondition = new SolidityIfElse();
solidityCondition.AddConditionBlock($"now > {GetTimerCondition()}", CreateTouchFunctionLogic(attachedToConverter));
function.AddToBody(solidityCondition);
function.AddToBody(new SolidityStatement("return true"));
return(function);
}
private SolidityFunction CreateTaskFunction()
{
SolidityFunction function = new SolidityFunction(GetElementCallName(), SolidityVisibility.Internal);
function.AddParameters(processConverter.GetIdentifiersAsParameters());
//Add the calls of the decision function in the right order
var declarations = GetDecisionFunctionDeclarations();
foreach (var declaration in declarations)
{
function.AddToBody(declaration);
}
//Get the delegation logic of the next connected element
function.AddToBody(processConverter.GetStatementOfNextElement(BusinessRuleTaskElement));
return(function);
}
public override IList <SolidityComponent> GetElementCode(List <ElementConverter> nextElements, IList <SequenceFlow> outgoingSeqFlows, IList <SolidityStruct> dataModel = null)
{
var logicFunction = new SolidityFunction(gateway.Id + "Logic", SolidityVisibility.Internal);
if (nextElements.Count == 1)
{
logicFunction.AddToBody(nextElements[0].GetStatementForPrevious(gateway));
}
else
{
logicFunction.AddToBody(CreateIfElseBlock(nextElements, outgoingSeqFlows));
}
return(new List <SolidityComponent> {
logicFunction
});
}
SolidityFunction CreateLogicFunction()
{
var logicFunction = new SolidityFunction($"{GetElementCallName()}", SolidityVisibility.Internal);
logicFunction.AddParameters(processConverter.GetIdentifiersAsParameters());
var outgoingSequenceFlows = processConverter.GetOutgoingSequenceFlows(gatewayElement);
if (outgoingSequenceFlows.Count == 1)
{
ElementConverter nextConverter = processConverter.GetConverterOfElement(outgoingSequenceFlows.First().TargetId);
logicFunction.AddToBody(nextConverter.GetStatementForPrevious(gatewayElement));
}
else
{
logicFunction.AddToBody(CreateIfElseBlock(outgoingSequenceFlows));
}
return(logicFunction);
}
//Functions for comparison of matched rule and already matched outputs
public override SolidityFunction CreateHelperFunction()
{
FunctionName = Regex.Replace(Decision.Id, @" ", "").ToLowerCamelCase();
SolidityFunction function = new SolidityFunction($"{FunctionName}_decideByPriority", SolidityVisibility.Internal, $"{OutputStructName} memory", true);
var prioritiesFormatted = GetPriorities(Decision);
var noUniqueOutputs = Regex.Matches(prioritiesFormatted, $"{OutputStructName}").Count;
function.AddParameter(new SolidityParameter($"{OutputStructName}[{noUniqueOutputs}] memory", "priorities"));
function.AddParameter(new SolidityParameter($"{OutputStructName} memory", "currentOutput"));
function.AddParameter(new SolidityParameter($"{OutputStructName} memory", "newOutput"));
var priorityComparison = GetPriorityComparisonBody();
var priorityIteration = new SolidityFor("i", $"{noUniqueOutputs}");
priorityIteration.AddToBody(new SolidityStatement(priorityComparison.ToString(), false));
function.AddToBody(priorityIteration);
function.AddToBody(new SolidityStatement("revert('Undefined output')", true));
return(function);
}
SolidityFunction CreateProcessReturnFunction()
{
var function = new SolidityFunction(ConversionTemplates.CallActivityReturnFunctionName(GetElementCallName()), SolidityVisibility.Internal);
function.AddParameters(processConverter.GetIdentifiersAsParameters());
var nextElementStatement = CreateNextElementStatement();
var incrementStatement = new SolidityStatement($"{ConversionTemplates.CallActivityCounter(GetElementCallName())}++");
var checkConditionBlock = new SolidityIfElse();
var calledStartEventConverter = processConverter.ContractConverter.GetStartEventConverter(callActivity);
var callSubprocessStatement = calledStartEventConverter.GetStatementForPrevious(callActivity);
checkConditionBlock.AddConditionBlock($"{ConversionTemplates.CallActivityCounter(GetElementCallName())} >= {GetCountTarget(callActivity)}",
nextElementStatement);
switch (callActivity.InstanceType)
{
case InstanceType.Single:
function.AddToBody(nextElementStatement);
break;
case InstanceType.Sequential:
//increment the counter, check if counter reached limit.
//If counter reached limit, then call the next element. If not, call the subprocess again.
function.AddToBody(incrementStatement);
checkConditionBlock.AddConditionBlock("", callSubprocessStatement);
function.AddToBody(checkConditionBlock);
break;
case InstanceType.Parallel:
//increment the counter, check if counter reached limit.
//If counter reached limit, then call the next element. If not, do nothing.
function.AddToBody(incrementStatement);
function.AddToBody(checkConditionBlock);
break;
}
return(function);
}
public override SolidityFunction CreateDecisionFunction()
{
FunctionName = Regex.Replace(Decision.Id, @" ", "").ToLowerCamelCase();
SolidityFunction function = new SolidityFunction(FunctionName, SolidityVisibility.Internal, $"{OutputStructName} memory", true);
//Add declaration of helper varaibles
function.AddToBody(new SolidityStatement($"{OutputStructName} memory output", true));
var emptyRule = false;
//Add checks of conditions for matches and their bodies
var rules = GetAllConditions();
foreach (var rule in rules.Select((value, i) => new { i, value }))
{
//Assign output if there is already the match
string conditionBody = GetConditionBody(rule.i);
//If the row is empty then do not put the logic into conditional statement
if (string.IsNullOrEmpty(rule.value))
{
var condition = new SolidityStatement(conditionBody, false);
function.AddToBody(condition);
emptyRule = true;
break;
}
else
{
var condition = new SolidityIfElse();
condition.AddConditionBlock(rule.value, new SolidityStatement(conditionBody, false));
function.AddToBody(condition);
}
}
//Add the rest of the function
if (!emptyRule)
{
function.AddToBody(new SolidityStatement("revert('Undefined output')", true));
}
return(function);
}
public override SolidityFunction CreateDecisionFunction()
{
//Define function's header
FunctionName = Regex.Replace(Decision.Id, @" ", "").ToLowerCamelCase();
SolidityFunction function = new SolidityFunction(FunctionName, SolidityVisibility.Internal, $"{OutputStructName}[] memory", true);
//Add declaration of helper varaibles
var prioritiesFormatted = GetPriorities();
var noUniqueOutputs = Regex.Matches(prioritiesFormatted, $"{OutputStructName}").Count;
function.AddToBody(new SolidityStatement($"{OutputStructName}[{noUniqueOutputs}] memory priorities = {prioritiesFormatted}", true));
function.AddToBody(new SolidityStatement($"bool[{noUniqueOutputs}] memory existsInOutput", true));
function.AddToBody(new SolidityStatement($"uint outputSize = 0", true));
function.AddToBody(new SolidityStatement($"bool matchedRule = false", true));
var rules = GetAllConditions();
foreach (var rule in rules.Skip(PriorityOffset).Select((value, i) => new { i, value }))
{
string priorityListCheck = GetPirorityListCheck(rule.i + PriorityOffset);
var priorityCheckLoop = new SolidityFor("i", $"{noUniqueOutputs}");
priorityCheckLoop.AddToBody(new SolidityStatement(priorityListCheck, false));
function.AddToBody(AddBodyBasedOnRule(rule.value, priorityCheckLoop.ToString()));
}
//Initialization of output list
function.AddToBody(new SolidityStatement("uint j = 0", true));
function.AddToBody(new SolidityStatement($"{OutputStructName}[] memory output = new {OutputStructName}[](outputSize)", true));
var initForLoop = GetInitializationForLoop(noUniqueOutputs);
function.AddToBody(initForLoop);
//Add the rest of the function
var undefinedOutputCheck = new SolidityIfElse();
undefinedOutputCheck.AddConditionBlock("!matchedRule", new SolidityStatement("revert('Undefined output')", true));
function.AddToBody(undefinedOutputCheck);
function.AddToBody(new SolidityStatement("return output", true));
return(function);
}
public override SolidityFunction CreateDecisionFunction()
{
//Define function's header
FunctionName = Regex.Replace(Decision.Id, @" ", "").ToLowerCamelCase();
SolidityFunction function = new SolidityFunction(FunctionName, SolidityVisibility.Internal, $"{OutputStructName} memory", true);
//Add declaration of helper varaibles
function.AddToBody(new SolidityStatement($"{OutputStructName} memory output", true));
function.AddToBody(new SolidityStatement($"output.{ Decision.DecisionTable.Outputs[0].Name.Replace(".", "__")} = 0", true));
//For each row representing rule create condition for if statement
var conditionBody = $"output.{ Decision.DecisionTable.Outputs[0].Name.Replace(".", "__")}++;";
var rules = GetAllConditions();
foreach (var rule in rules)
{
function.AddToBody(AddBodyBasedOnRule(rule, conditionBody));
}
//Add the rest of the function
function.AddToBody(new SolidityStatement("return output", true));
return(function);
}
public override void ConvertElementLogic()
{
mainFunction = CreateMainFunction();
incomingFlowsVariable = CreateIncomingFlowsVariable();
}
public override void ConvertElementLogic()
{
logicFunction = CreateLogicFunction();
}
public override void ConvertElementLogic()
{
mainFunction = CreateTaskFunction();
}
private SolidityFunction GetFunction()
{
SolidityFunction f = new SolidityFunction(functionName, visibility);
return(f);
}
