/// <summary>
/// It recursively buffers the InstanceBlueprint division rules (in result list) for all child instances, in order to
/// get the result of only relevant child, we use childOrderTracer which is kind of the ID of child instance, if the
/// recursion arrives this child then performs calculations over buffered @param result.
/// </summary>
/// <param name="divisionRules"></param>
/// <param name="ruleCount"></param>
/// <param name="result">Holds list of InstanceBlueprint of division rules</param>
private static void getRulePermutation(List <KpCore.Rule> divisionRules, int ruleCount, List <InstanceBlueprint> result)
{
//if it completes on cycle of recursion
if (ruleCount == divisionRules.Count)
{
//check if this cycle belongs to requested child instance
if (childOrderTracer == (kPInstance as KPChildInstance).Order)
{
//then perform calculation
calculateValuesOfDivisionVariables(divisionRules, result);
}
childOrderTracer++;
return;
}
DivisionRule divisionRule = (DivisionRule)divisionRules.ElementAt(ruleCount);
int compartCount = divisionRule.Rhs.Count;
ruleCount++;
for (int j = 0; j < compartCount; j++)
{
InstanceBlueprint compartment = divisionRule.Rhs.ElementAt(j);
int index = ruleCount - 1;
if (result.Count < ruleCount)
{
result.Insert(index, compartment);
}
else
{
result.RemoveAt(index);
result.Insert(index, compartment);
}
getRulePermutation(divisionRules, ruleCount, result);
}
}
private static void getRulePermutation(ParentInstance parentInstance, List <KpCore.Rule> divisionRules, int ruleCount, List <InstanceBlueprint> result)
{
if (ruleCount == divisionRules.Count)
{
formDivisionInstance(parentInstance, divisionRules, result);
return;
}
DivisionRule divisionRule = (DivisionRule)divisionRules.ElementAt(ruleCount);
int compartCount = divisionRule.Rhs.Count;
ruleCount++;
for (int j = 0; j < compartCount; j++)
{
InstanceBlueprint compartment = divisionRule.Rhs.ElementAt(j);
int index = ruleCount - 1;
if (result.Count < ruleCount)
{
result.Insert(index, compartment);
}
else
{
result.RemoveAt(index);
result.Insert(index, compartment);
}
getRulePermutation(parentInstance, divisionRules, ruleCount, result);
}
}
private void writeInstanceBlueprint(InstanceBlueprint ib)
{
owt.Write("{");
owt.Write("\"type\":\"" + ib.Type.Name + "\"");
owt.Write(", \"multiset\":");
writeMultiset(ib.Multiset);
owt.Write("}");
}
public void AddInstanceBlueprint(InstanceBlueprint ib, IndexedMType imt)
{
if (newInstances == null)
{
newInstances = new HashSet <ActiveInstanceBlueprint>();
}
newInstances.Add(new ActiveInstanceBlueprint(ib, imt));
}
public object VisitDivision(KpLinguaParser.DivisionContext context)
{
var instanceBlueprint = default(InstanceBlueprint);
var typeReferenceContext = context.typeReference();
var multisetContext = context.nonEmptyMultiset();
var type = typeReferenceContext != null?typeReferenceContext.Accept(this) as MType : _kPsystem[_currentTypeName];
if (multisetContext != null)
{
instanceBlueprint = new InstanceBlueprint(type, multisetContext.Accept(this) as Multiset);
}
else
{
instanceBlueprint = new InstanceBlueprint(type);
}
return(instanceBlueprint);
}
private Rule readRule(XPathNavigator nav)
{
ConsumerRule rule = null;
XPathNavigator rhsNav = nav.SelectSingleNode("rhs");
if (rhsNav != null)
{
Multiset m = readMultiset(rhsNav);
XPathNodeIterator div;
if (m.IsEmpty())
{
//then we can have structure changing rules
div = rhsNav.SelectChildren("instance", String.Empty);
if (div.Count > 0)
{
DivisionRule r = new DivisionRule();
while (div.MoveNext())
{
string mtype = div.Current.GetAttribute("mtype", String.Empty);
InstanceBlueprint ib = null;
if (String.IsNullOrEmpty(mtype))
{
ib = new InstanceBlueprint(currentType);
}
else
{
ib = new InstanceBlueprint(kp[mtype]);
}
readMultiset(div.Current, ib.Multiset);
r.Rhs.Add(ib);
}
rule = r;
}
else
{
XPathNavigator v;
v = rhsNav.SelectSingleNode("linkCreate");
if (v == null)
{
v = rhsNav.SelectSingleNode("linkDestroy");
if (v == null)
{
v = rhsNav.SelectSingleNode("dissolve");
if (v != null)
{
rule = new DissolutionRule();
}
}
else
{
rule = LinkRule.LinkDestroy(readInstanceIdentifier(v));
}
}
else
{
rule = LinkRule.LinkCreate(readInstanceIdentifier(v));
}
}
}
if (rule == null)
{
div = rhsNav.SelectChildren("target", String.Empty);
if (div.Count > 0)
{
RewriteCommunicationRule rcr = new RewriteCommunicationRule();
rcr.Rhs.Add(m);
while (div.MoveNext())
{
TargetedMultiset tm = readTargetedMultiset(div.Current);
TargetedMultiset otm = null;
rcr.TargetRhs.TryGetValue(tm.Target, out otm);
if (otm == null)
{
rcr.TargetRhs.Add(tm.Target, tm);
}
else
{
otm.Multiset.Add(tm.Multiset);
}
}
rule = rcr;
}
else if (m != null)
{
rule = new RewritingRule();
(rule as RewritingRule).Rhs.Add(m);
}
}
}
if (rule == null)
{
rule = new ConsumerRule();
}
readPItem(nav, rule);
rule.Guard = readGuard(nav.SelectSingleNode("guard"));
readMultiset(nav.SelectSingleNode("lhs"), rule.Lhs);
return(rule);
}
public ActiveInstanceBlueprint(InstanceBlueprint ib, IndexedMType imt)
{
InstanceBlueprint = ib;
IndexedMType = imt;
}
