/// <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; }