/// <summary>
/// returns connection Variable which corresponds to given module
/// </summary>
/// <param name="targetModule"></param>
/// <returns></returns>
public NoNextVar getConnectionToModule(Module targetModule)
{
NoNextVar result = null;
foreach (var connection in connections)
{
if (connection.Name.Equals(SMVPreFix.getConnectionVar(targetModule)))
{
result = connection;
break;
}
}
return(result);
}
/// <summary>
/// If current module has more than one connection to
/// target module, then returns true, false otherwise.
/// </summary>
/// <param name="targetModule"></param>
/// <returns></returns>
public bool connectionToModuleExist(Module targetModule)
{
bool result = false;
foreach (var connection in connections)
{
if (connection.Name.Equals(SMVPreFix.getConnectionVar(targetModule)))
{
result = true;
break;
}
}
return(result);
}
private static void assignStatusAndSyncToAVariable(Module module, IVar variable)
{
if (variable is Variable)
{
CaseLine caseLine = new CaseLine();
Variable var = (Variable)variable;
String exchangeState = SynchStates.EXCHANGE;
//For Copy variables inside module
if (var.Origin == VariableOrigin.Copy || var.Origin == VariableOrigin.CopyOfCommVar)
{
Expression result = new Expression("0");
caseLine.Rule.Condition = getStatusAndSynchCondition(module, exchangeState);
caseLine.Result = result;
var.Next.CaseStatement.CaseLines.Add(caseLine);
}
//For Original variables inside module
else if (var.Origin == VariableOrigin.Original && var.Behaviour != VariableBehaviour.COMMUNICATION)
{
//if it has copy var, then add var + var_cp
if (module.isVariableExist(SMVPreFix.getCopyName(var)))
{
OperExp result = new OperExp();
result.Exp = variable.Name;
result.Oper.Value = MathOper.ADD;
//if variable is a division variable, then it has go to main part, like comm vars, so it will be instanced.
if (var.Behaviour == VariableBehaviour.DIVISION)
{
result.Result = new InstancedExp(variable.Name + SMVPreFix.COPY);
}
else
{
result.Result = new Expression(variable.Name + SMVPreFix.COPY);
}
ICondition boundCondition = getBoundCondition(var, result);
caseLine.Rule.Condition = new CompoundBoolExpression(getStatusAndSynchCondition(module, exchangeState), BinaryOperator.AND, boundCondition);
caseLine.Result = result;
var.Next.CaseStatement.CaseLines.Add(caseLine);
}
}
//for communication variables, goes into main module.
else if (var.Origin == VariableOrigin.OriginalCommVar && var.Behaviour == VariableBehaviour.COMMUNICATION)
{
CaseLine commCaseLine = assignStatusAndSyncToACommVariable(module, var);
var.Next.CaseStatement.CaseLines.Add(commCaseLine);
}
}
}
private static CaseLine assignStatusAndSyncToACommVariable(Module module, Variable variable)
{
CaseLine commCaseLine = new CaseLine();
OperExp result = new OperExp();
result.Exp = new InstancedExp(module.Instance.Name, variable.Name).ToString();
result.Oper.Value = MathOper.ADD;
//if it has copy var, then add var + var_cp
string res = "";
if (module.isVariableExist(SMVPreFix.getCopyName(variable)))
{
res += new InstancedExp(module.Instance.Name, SMVPreFix.getCopyName(variable));
}
foreach (var connectedInstance in module.Instance.ConnectedTo)
{
if (connectedInstance.Module.isVariableExist(SMVPreFix.getConnectedCopyCommVarName(variable, module)))
{
if (!string.IsNullOrWhiteSpace(res))
{
res += " + ";
}
res += new InstancedExp(connectedInstance.Name, SMVPreFix.getConnectedCopyCommVarName(variable, module));
}
}
result.Result = new Expression(res);
//(c1.status = _ACTIVE)
CompoundBoolExpression statusAndSync = getInstancedStatusAndSyncCondition(module);
ICondition boundCondition = getBoundCondition(variable, result);
ICondition compound = new CompoundBoolExpression(statusAndSync, BinaryOperator.AND, boundCondition);
CommunicationRule rule = new CommunicationRule();
rule.Condition = compound;
//commCaseLine.Rule.Condition = compound;
commCaseLine.Rule = rule;
commCaseLine.Result = result;
return(commCaseLine);
}
private static List <NoNextVar> generateConnectionVariable(KPsystem kpSystem, MType kpType, Module module)
{
List <NoNextVar> connections = new List <NoNextVar>();
foreach (MType mType in kpSystem.Types)
{
NoNextVar connection = new NoNextVar(SMVPreFix.getConnectionVar(mType));
connection.Behaviour = VariableBehaviour.CUSTOM;
SEnum connEnums = new SEnum();
HashSet <Instance> connectedTo = new HashSet <Instance>();
foreach (var connectedInstance in module.Instance.ConnectedTo)
{
// if it has connection
if (connectedInstance.Module.Type == mType.Name)
{
bool communicationRuleToTargetExist = communicationRuleIncludesTargetType(kpType, mType);
if (communicationRuleToTargetExist)
{
connectedTo.Add(connectedInstance);
}
}
}
//if there is more than one connection of same type compartments exists, then add it to connections
if (connectedTo.Count > 1)
{
//sort them
IEnumerable <Instance> orderedConns = connectedTo.OrderBy(instance => instance.Name);
foreach (var connectedInstance in orderedConns)
{
connEnums.Values.Add(SMVPreFix.getConnectedTo(connectedInstance));
}
connection.Type = connEnums;
// connection.Init = setOrUpdateInit(module, connection); Commented out, since no need to get from parameter.
connections.Add(connection);
}
}
return(connections);
}
internal static void addCaseLineToCurrentCopyCommVar(Variable orjVariable, Variable copyCommVar, KpCore.Rule rule, Module module, Module targetModule, int strategyIndex)
{
//for each variable generate a case line
CaseLine caseLine = new CaseLine();
OperExp result = new OperExp();
int resultValue = 0;
RewriteCommunicationRule rcr = (RewriteCommunicationRule)rule;
foreach (var target in rcr.TargetRhs.Values)
{
TargetedMultiset targetMultiSet = (TargetedMultiset)target;
InstanceIdentifier targetType = (InstanceIdentifier)targetMultiSet.Target;
if (targetModule.Type == targetType.Value)
{
Multiset ms = targetMultiSet.Multiset;
foreach (var obj in ms.Objects)
{
if (obj.Equals(orjVariable.Name))
{
resultValue += ms[obj];
}
}
}
}
result.Exp = copyCommVar.Name;
if (resultValue != 0)
{
result.Oper.Value = MathOper.ADD;
result.Result = new Expression(resultValue.ToString());
}
caseLine.Result = result;
caseLine.Rule = BRulesStandardVar.extractStandardRuleFromKPRule(rule, module, strategyIndex);
ICondition sequenceCondition = BRulesStandardVar.getSequenceCondition(module, strategyIndex, rule.Id);
ICondition targetBounds = getBoundCondition(copyCommVar, caseLine.Result);
CompoundBoolExpression sequenceAndBound = new CompoundBoolExpression(sequenceCondition, BinaryOperator.AND, targetBounds);
ICondition statusCondition = BRulesStandardVar.getTurnCondition(module, strategyIndex);
CompoundBoolExpression statusAndSequence = new CompoundBoolExpression(statusCondition, BinaryOperator.AND, sequenceAndBound);
// _conn = to_c2
if (module.connectionToModuleExist(targetModule))
{
BoolExp connEqInstance = new BoolExp(module.getConnectionToModule(targetModule).Name, NuSMV.RelationalOperator.EQUAL, SMVPreFix.getConnectedTo(targetModule.Instance));
caseLine.Rule.AddBoolExpression(connEqInstance, BinaryOperator.AND);
}
caseLine.Rule.AddBoolExpression(statusAndSequence, BinaryOperator.AND);
caseLine.Rule.ID = rule.Id;
if (copyCommVar.Next != null)
{
//if the case line has not added yet
if (!ruleExist(copyCommVar.Next, caseLine))
{
copyCommVar.Next.addCaseLine(caseLine);
}
}
}
private static void buildCommunicationVariables(SMVModel nuSMV, NuSMV.Module module, KPsystem kpSystem, KpCore.MType type, int strategyIndex, KpCore.Rule rule)
{
RewriteCommunicationRule rcr = (RewriteCommunicationRule)rule;
string varName = "";
VariableOrigin origin = VariableOrigin.Original;
bool isLeft = true;
//regular left hand-side rules
foreach (var leftHRule in rcr.Lhs)
{
varName = leftHRule.Key;
isLeft = true;
buildReWritingVariable(kpSystem, type, module, strategyIndex, rule, varName, origin, isLeft);
}
//regular right hand-side rules
foreach (var rigthHRule in rcr.Rhs)
{
varName = rigthHRule.Key;
origin = VariableOrigin.Original;
isLeft = false;
//first generate original one, then its copy
if (!module.isVariableExist(varName))
{
buildReWritingVariable(kpSystem, type, module, strategyIndex, rule, varName, origin, isLeft);
}
string copyVarName = varName + SMVPreFix.COPY;
origin = VariableOrigin.Copy;
buildReWritingVariable(kpSystem, type, module, strategyIndex, rule, copyVarName, origin, isLeft);
}
//Targeted rules
foreach (var target in rcr.TargetRhs.Values)
{
TargetedMultiset targetMultiSet = (TargetedMultiset)target;
InstanceIdentifier targetTypeIdentifier = (InstanceIdentifier)targetMultiSet.Target;
MType targetType = null;
foreach (var tempType in kpSystem.Types)
{
if (tempType.Name == targetTypeIdentifier.Value)
{
targetType = tempType;
}
}
//for each connected instance of the target type, create a copy variable foreach object in the multiset
foreach (var connectedInstance in module.Instance.ConnectedTo)
{
if (connectedInstance.Module.Type == targetType.Name)
{
Module targetModule = connectedInstance.Module;
Multiset ms = targetMultiSet.Multiset;
foreach (var obj in ms.Objects)
{
varName = obj;
Variable targetVariable = new Variable(varName);
string currentCpVarName = SMVPreFix.getConnectedCopyCommVarName(varName, targetModule);
Variable currentCpVar = new Variable(currentCpVarName);
//create original variable inside target module
if (!targetModule.isVariableExist(varName))
{
setBoundIntType(kpSystem, targetType, targetModule, targetVariable);
targetVariable.Behaviour = VariableBehaviour.COMMUNICATION;
targetVariable.Origin = VariableOrigin.OriginalCommVar;
targetVariable.Init = setOrUpdateInit(targetModule, targetVariable);
targetModule.Variables.Add(targetVariable);
}
else
{
//if variable is already in target module, then make sure, it is set as communication var.
targetVariable = (Variable)targetModule.Variables.First(item => item.Name.Equals(varName));
targetVariable.Behaviour = VariableBehaviour.COMMUNICATION;
targetVariable.Origin = VariableOrigin.OriginalCommVar;
targetVariable.Init = setOrUpdateInit(targetModule, targetVariable);
}
//create a varName_InstanceName_TargetModule, variable (as copy) inside current module.
if (!module.isVariableExist(currentCpVarName))
{
Variable orginalVariable = (Variable)targetModule.getVariable(varName);
currentCpVar.Type = orginalVariable.Type;
currentCpVar.Behaviour = VariableBehaviour.REWRITING;
currentCpVar.Origin = VariableOrigin.CopyOfCommVar;
currentCpVar.Init = "0";
module.Variables.Add(currentCpVar);
}
else
{
//if variable exists then update the values.
currentCpVar = (Variable)module.Variables.First(item => item.Name.Equals(currentCpVarName));
}
//add result of rule to caseline
BRulesComVar.addCaseLineToCurrentCopyCommVar(targetVariable, currentCpVar, rule, module, targetModule, strategyIndex);
}
}
}
}
}
