private MocaNode processEPackage(SQLPackage eaPackage) { //backgroundWorker.ReportProgress(0, PersistencyUtil.computePackageUri(eaPackage, repository)); //SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaPackage, Main.MoflonRefactorTreeTaggedValueName); //if (mocaTreeTag == null) SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaPackage, Main.MoflonExportTreeTaggedValueName); if (mocaTreeTag != null) { EPackage ePackage = new EPackage(eaPackage, repository); MocaNode ePackageMocaNode = MocaTreeUtil.mocaNodeFromXmlString(mocaTreeTag.Notes); ePackage.addAttributesDuringExport(ePackageMocaNode); this.currentNode.appendChildNode(ePackageMocaNode); foreach (SQLElement childClass in eaPackage.Elements) { this.currentNode = ePackageMocaNode.getChildNodeWithName(EPackageHelper.ClassesChildNodeName); if (childClass.Stereotype.ToLower() == ECOREModelingMain.EClassStereotype.ToLower()) { processEClass(childClass); } } foreach (SQLPackage childPackage in eaPackage.Packages) { this.currentNode = ePackageMocaNode.getChildNodeWithName(EPackageHelper.PackagesChildNodeName); processEPackage(childPackage); } return(ePackageMocaNode); } return(null); }
public void processObjectVariable(SQLElement objectVariable) { SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(objectVariable, Main.MoflonExportTreeTaggedValueName); ObjectVariable ov = new ObjectVariable(objectVariable, repository); ov.loadTreeFromTaggedValue(); SQLElement classifier = EAUtil.getClassifierElement(repository, objectVariable.ClassifierID); if (classifier != null) { Export.computeAndAddToDependencies(repository, classifier); } MocaNode ovMocaNode = new MocaNode(); ovMocaNode.deserializeFromXmlTree(MocaTreeUtil.stringToXmlDocument(mocaTreeTag.Notes).DocumentElement.FirstChild as XmlElement); ov.addAttributesDuringExport(ovMocaNode); this.currentNode.appendChildNode(ovMocaNode); foreach (SQLConnector linkVariable in objectVariable.Connectors) { if ((linkVariable.Stereotype == SDMModelingMain.LinkVariableStereotype || linkVariable.Stereotype == "SDM_Association") && linkVariable.ClientID == objectVariable.ElementID) { this.currentNode = ovMocaNode.getChildNodeWithName(ObjectVariable.OutgoingLinksNodeName); processLinkVariable(linkVariable); } } }
public void processTggEReference(SQLConnector eaReference, String clientOrSupplier) { SQLConnectorTag mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaReference, Main.MoflonExportTreeTaggedValueName); MocaNode referenceEndNode = new MocaNode(); referenceEndNode.deserializeFromXmlTree(MocaTreeUtil.stringToXmlDocument(mocaTreeTag.Notes).DocumentElement.FirstChild as XmlElement); SQLElement eTypeElement = null; if (clientOrSupplier == "Client") { referenceEndNode = referenceEndNode.getChildNodeWithName(EReference.ClientReferenceChildNodeName).Children[0]; eTypeElement = repository.GetElementByID(eaReference.ClientID); } else if (clientOrSupplier == "Supplier") { referenceEndNode = referenceEndNode.getChildNodeWithName(EReference.SupplierReferenceChildNodeName).Children[0]; eTypeElement = repository.GetElementByID(eaReference.SupplierID); } ExportMain.computeAndAddToDependencies(repository, eTypeElement); this.currentNode.appendChildNode(referenceEndNode); }
public void importEPackageFeatures(MocaNode ePackageNode, SQLPackage modelPackage) { foreach (MocaNode eclassNode in ePackageNode.getChildNodeWithName(EPackageHelper.ClassesChildNodeName).Children) { if (eclassNode.Name == ECOREModelingMain.EClassStereotype) { importEClass(modelPackage, eclassNode); } else if (eclassNode.Name == ECOREModelingMain.EDatatypeStereotype) { importEDatatype(modelPackage, eclassNode); } else if (eclassNode.Name == ECOREModelingMain.EEnumStereotype) { importEEnum(modelPackage, eclassNode); } } foreach (MocaNode packageNode in ePackageNode.getChildNodeWithName(EPackageHelper.PackagesChildNodeName).Children) { if (packageNode.Name == ECOREModelingMain.EPackageStereotype) { importEPackage(packageNode, modelPackage); } } }
public SQLMethod findMethodFromMocaNode(SQLElement parent, MocaNode methodNode) { SQLMethod found = null; foreach (SQLMethod method in parent.Methods) { int validCount = 0; if (method.Name == methodNode.getAttributeOrCreate("name").Value) { foreach (SQLParameter param in method.Parameters) { foreach (MocaNode paramNode in methodNode.getChildNodeWithName(EOperation.ParametersChildNodeName).Children) { if (paramNode.getAttributeOrCreate("name").Value == param.Name) { validCount++; } } } if (validCount == method.Parameters.Count && validCount == methodNode.getChildNodeWithName(EOperation.ParametersChildNodeName).Children.Count) { found = method; } } } return(found); }
private void loadCSPConstraints(MocaNode actNode) { MocaNode constraintsNode = actNode.getChildNodeWithName(ConstraintsChildNodeName); if (constraintsNode != null) { Constraints.Clear(); foreach (MocaNode constraintNode in actNode.getChildNodeWithName(ConstraintsChildNodeName).Children) { if (constraintNode.Name == DeclarationsChildNodeName) { foreach (MocaNode constraintNodeReal in constraintNode.Children) { CSPConstraint newConstr = new CSPConstraint(); newConstr.deserializeFromMocaTree(constraintNodeReal); this.Constraints.Add(newConstr); } } else if (constraintNode.Name == ConstraintInstancesChildNodeName) { } else { CSPConstraint newConstr = new CSPConstraint(); newConstr.deserializeFromMocaTree(constraintNode); this.Constraints.Add(newConstr); } } } CSPUtil.addDefaultConstraints(Constraints); this.Constraints.Sort(new CSPConstraintComparer()); CSPUtil.recomputeConstraintIndizes(Constraints); }
public override void deserializeFromMocaTree(Serialization.MocaTree.MocaNode actNode) { MocaNode constExpNode = actNode.getChildNodeWithName("constraintExpression"); this.ConstraintExpression = Expression.createExpression(constExpNode.getAttributeOrCreate("type").Value, Repository) as ComparisonExpression; this.ConstraintExpression.deserializeFromMocaTree(constExpNode); }
public override Serialization.MocaTree.MocaNode serializeToMocaTree() { MocaNode epackageNode = new MocaNode(ECOREModelingMain.EPackageStereotype); helper.serializeToMocaTree(epackageNode); return(epackageNode); }
private void addAttributes(MocaNode pkgNode) { pkgNode.appendChildAttribute(MoflonCustomPluginIDTaggedValueName, computePluginID()); pkgNode.appendChildAttribute(MoflonExportTaggedValueName, computeExportAttribute()); pkgNode.appendChildAttribute(MoflonValidatedTaggedValueName, computeValidatedAttribute()); pkgNode.appendChildAttribute(MoflonWorkingSetTaggedValueName, computeRootNodeName()); }
public override Serialization.MocaTree.MocaNode serializeToMocaTree(MocaNode actNode) { MocaNode exp = actNode; exp.appendChildAttribute("type", this.Type); return(exp); }
public override Serialization.MocaTree.MocaNode serializeToMocaTree(MocaNode actNode) { MocaNode node = base.serializeToMocaTree(actNode); node.appendChildAttribute("expressionText", this.ExpressionText); return(node); }
private void savePackageChangesToEATaggedValue(SQLRepository sqlRepository, String GUID) { SQLPackage sqlPackage = sqlRepository.GetPackageByGuid(GUID); EPackage epackage = new EPackage(sqlPackage, sqlRepository); String packages = addPackageName(epackage, "", sqlRepository); String previousName = sqlPackage.Name; SQLTaggedValue changesTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(sqlPackage, Main.MoflonChangesTreeTaggedValueName); if (changesTreeTag != null) { MocaNode eClassMocaNode = MocaTreeUtil.mocaNodeFromXmlString(changesTreeTag.Notes); previousName = eClassMocaNode.getAttribute("previousName").Value; } CachedPackage temp = new CachedPackage(); temp.getPackage(GUID, sqlRepository); temp.name = sqlPackage.Name; temp.previousName = previousName; temp.packageName = packages; temp.projectName = getTopLevelPackageName(sqlPackage, sqlRepository); temp.savePackageToEATaggedValue(true); }
private void saveElementChangesToEATaggedValue(SQLElement eaElement, String GUID, SQLRepository sqlRepository) { SQLPackage package = sqlRepository.GetPackageByID(eaElement.PackageID); EPackage epackage = new EPackage(package, sqlRepository); // String packages = addPackageName(epackage, "", sqlRepository); String previousName = eaElement.Name; SQLTaggedValue exportTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaElement, Main.MoflonExportTreeTaggedValueName); /*if (exportTreeTag != null) * { * MocaNode eClassMocaNode = MocaTreeUtil.mocaNodeFromXmlString(exportTreeTag.Notes); * MocaNode eClassAttributes = eClassMocaNode.Children[1]; * eClassAttributes.getAttribute() * * previousName = eClassMocaNode.getAttribute("previousName").Value; * }*/ SQLTaggedValue changesTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaElement, Main.MoflonChangesTreeTaggedValueName); if (changesTreeTag != null) { MocaNode eClassMocaNode = MocaTreeUtil.mocaNodeFromXmlString(changesTreeTag.Notes); previousName = eClassMocaNode.getAttribute("previousName").Value; } CachedClass temp = new CachedClass(); temp.getElement(GUID, sqlRepository); temp.name = eaElement.Name; temp.previousName = previousName; temp.packageName = addPackageName(epackage, "", sqlRepository); temp.projectName = getTopLevelPackageName(package, sqlRepository); temp.saveElementToEATaggedValue(true); }
public MocaNode processEClass(SQLElement eaClass) { SQLTaggedValue refactorTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaClass, Main.MoflonRefactorTreeTaggedValueName); if (refactorTreeTag != null) { EClass eClass = new EClass(eaClass, repository); eClass.loadTreeFromTaggedValue(); MocaNode eClassMocaNode = MocaTreeUtil.mocaNodeFromXmlString(refactorTreeTag.Notes); eClass.addMocaAttributesDuringExport(eClassMocaNode); //add baseclass dependencies /*foreach (var baseClass in eClassMocaNode.getAttributeOrCreate("baseClasses").Value.Split(" ".ToArray())) * { * if (baseClass != "") * { * SQLElement baseclass = repository.GetElementByGuid(baseClass); * Export.computeAndAddToDependencies(repository, baseclass); * } * }*/ this.currentNode.appendChildNode(eClassMocaNode); return(eClassMocaNode); } return(null); }
public MocaNode processEClass(SQLElement eaClass) { SQLTaggedValue changesTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaClass, Main.MoflonChangesTreeTaggedValueName); if (changesTreeTag != null) { EClass eClass = new EClass(eaClass, repository); eClass.loadTreeFromTaggedValue(); MocaNode eClassMocaNode = MocaTreeUtil.mocaNodeFromXmlString(changesTreeTag.Notes); eClass.addMocaAttributesDuringExport(eClassMocaNode); this.currentNode.appendChildNode(eClassMocaNode); if (eClassMocaNode.hasAllAttributes(new List <string>( new string[] { ChangesTreeConstants.ATTRIBUTE_KEY_PACKAGE_NAME, ChangesTreeConstants.ATTRIBUTE_KEY_PROJECT_NAME }))) { String packageName = eClassMocaNode.getAttribute(ChangesTreeConstants.ATTRIBUTE_KEY_PACKAGE_NAME).Value; String projectName = eClassMocaNode.getAttribute(ChangesTreeConstants.ATTRIBUTE_KEY_PROJECT_NAME).Value; CachedClass temp = new CachedClass(); temp.getElement(eaClass.ElementGUID, repository); temp.name = eClass.Name; temp.previousName = eClass.Name; temp.packageName = packageName; temp.projectName = projectName; temp.saveElementToEATaggedValue(true); return(eClassMocaNode); } } return(null); }
private MocaNode extractFromReferencesNode(MocaNode ereferenceNode) { MocaNode erefNode = null; if (ereferenceNode.Name == EClass.ReferencesChildNodeName) { foreach (MocaNode childNode in ereferenceNode.Children) { if (ereferenceNode.Children.Count == 2) { //String a = ""; } if (childNode.getAttributeOrCreate(Main.GuidStringName).Value.Contains("Client") && ConnectorEnd.End == "Client") { erefNode = childNode; break; } else if (childNode.getAttributeOrCreate(Main.GuidStringName).Value.Contains("Supplier") && ConnectorEnd.End == "Supplier") { erefNode = childNode; break; } } } return(erefNode); }
public override void deserializeFromMocaTree(Serialization.MocaTree.MocaNode actNode) { base.deserializeFromMocaTree(actNode); MocaNode domainsNode = actNode.getChildNodeWithName("domains"); MocaNode metamodelsNode = actNode.getChildNodeWithName("metamodels"); Name = EaPackage.Name; if (metamodelsNode != null) { foreach (MocaNode mmNode in metamodelsNode.Children) { Metamodel mm = new Metamodel(); mm.deserializeFromMocaTree(mmNode); this.Metamodels.Add(mm); } } if (domainsNode != null) { foreach (MocaNode dNode in domainsNode.Children) { Domain mm = new Domain(); mm.deserializeFromMocaTree(dNode); this.Domains.Add(mm); } } loadCSPConstraints(actNode); }
public override MocaNode serializeToMocaTree(MocaNode actNode) { MocaNode dummyNode = null; EcoreUtil.computeLowerUpperBound(ConnectorEnd.getRealConnectorEnd().Cardinality, ref lowerBound, ref upperBound); if (ConnectorEnd.getRealConnectorEnd().End == "Client") { dummyNode = actNode.appendChildNode("ClientReference"); SQLElement clientEClass = Repository.GetElementByID(this.EaConnector.getRealConnector().ClientID); typeGUID = clientEClass.ElementGUID; refGUID = this.EaConnector.getRealConnector().ConnectorGUID + "Client"; if (this.EaConnector.getRealConnector().SupplierEnd.Role != "") { oppositeGUID = this.EaConnector.getRealConnector().ConnectorGUID + "Supplier"; } containment = this.EaConnector.getRealConnector().SupplierEnd.Aggregation == 2; } else if (ConnectorEnd.getRealConnectorEnd().End == "Supplier") { dummyNode = actNode.appendChildNode("SupplierReference"); SQLElement supplierEClass = Repository.GetElementByID(this.EaConnector.getRealConnector().SupplierID); typeGUID = supplierEClass.ElementGUID; refGUID = this.EaConnector.getRealConnector().ConnectorGUID + "Supplier"; if (this.EaConnector.getRealConnector().ClientEnd.Role != "") { oppositeGUID = this.EaConnector.getRealConnector().ConnectorGUID + "Client"; } containment = this.EaConnector.getRealConnector().ClientEnd.Aggregation == 2; } if (Navigable) { MocaNode ereferenceNode = dummyNode.appendChildNode("EReference"); ereferenceNode.appendChildAttribute("typeGuid", typeGUID); if ((ConnectorEnd.Role == "" || ConnectorEnd.getRealConnectorEnd().Role == null)) { ereferenceNode.appendChildAttribute("name", this.Name); } else { ereferenceNode.appendChildAttribute("name", ConnectorEnd.getRealConnectorEnd().Role); } ereferenceNode.appendChildAttribute(Main.GuidStringName, refGUID); ereferenceNode.appendChildAttribute("lowerBound", lowerBound); ereferenceNode.appendChildAttribute("upperBound", upperBound); ereferenceNode.appendChildAttribute("containment", (containment + "").ToLower()); if (oppositeGUID != "") { ereferenceNode.appendChildAttribute("oppositeGuid", oppositeGUID); } } return(dummyNode); }
public override Serialization.MocaTree.MocaNode serializeToMocaTree(MocaNode actNode) { MocaNode constExp = actNode.appendChildNode("constraintExpression"); this.ConstraintExpression.serializeToMocaTree(constExp); return(actNode); }
public override void deserializeFromMocaTree(Serialization.MocaTree.MocaNode actNode) { MocaAttribute guidAttr = actNode.getAttributeOrCreate(Main.GuidStringName); MocaAttribute typeGuidAttr = actNode.getAttributeOrCreate("typeGuid"); this.typeGuid = typeGuidAttr.Value; this.guid = actNode.getAttributeOrCreate(Main.GuidStringName).Value; this.returnType = actNode.getAttributeOrCreate("returnType").Value; this.Name = actNode.getAttributeOrCreate("name").Value; MocaNode parametersNode = actNode.getChildNodeWithName(EOperation.ParametersChildNodeName); foreach (MocaNode eParamNode in parametersNode.Children) { if (eParamNode.Name == "EParameter") { foreach (SQLParameter neededParam in this.EaMethod.Parameters) { if (neededParam.Name == eParamNode.getAttributeOrCreate("name").Value) { EParameter eParam = new EParameter(neededParam, Repository); eParam.deserializeFromMocaTree(eParamNode); this.EParameters.Add(eParam); } } } } //only for import purposes }
private void getSourceAndClient(EA.Element parent, MocaNode referencesNode, ref EA.Element client, ref EA.Element supp) { try { if (referencesNode.Children[0].getAttributeOrCreate(Main.GuidStringName).Value.Contains("Client")) { client = MainImport.getInstance().ElementGuidToElement[referencesNode.Children[0].getAttributeOrCreate("typeGuid").Value]; } else { client = MainImport.getInstance().ElementGuidToElement[referencesNode.Children[1].getAttributeOrCreate("typeGuid").Value]; } } catch { client = parent; } try { if (referencesNode.Children[0].getAttributeOrCreate(Main.GuidStringName).Value.Contains("Supplier")) { supp = MainImport.getInstance().ElementGuidToElement[referencesNode.Children[0].getAttributeOrCreate("typeGuid").Value]; } else { supp = MainImport.getInstance().ElementGuidToElement[referencesNode.Children[1].getAttributeOrCreate("typeGuid").Value]; } } catch { supp = parent; } }
public override MocaNode serializeToMocaTree() { EClass dummyEClass = new EClass(this.rule, Repository); dummyEClass.computeFeatures(); MocaNode ruleNode = dummyEClass.serializeToMocaTree(); ruleNode.Name = "Rule"; MocaNode operationsNode = ruleNode.getChildNodeWithName(EClass.OperationsChildNodeName); MocaNode toDelete = null; if (operationsNode != null) { foreach (MocaNode node in operationsNode.Children) { MocaAttribute nameAttr = node.getAttributeOrCreate("name"); if (nameAttr != null && nameAttr.Value == this.Name) { toDelete = node; } } } if (toDelete != null) { operationsNode.Children.Remove(toDelete); } ruleNode.appendChildAttribute(TGGRule.CspSpecAttributeName, ""); ruleNode.appendChildAttribute("refines", ""); ruleNode.appendChildAttribute("baseClasses", ""); ruleNode.appendChildNode(StoryPattern.ObjectVariablesChildNodeName); return(ruleNode); }
public EA.Parameter getOrCreateParameter(EA.Method parentMethod, MocaNode attributeNode) { String oldGuid = attributeNode.getAttributeOrCreate(Main.GuidStringName).Value; String result = repository.SQLQuery("select * from t_operationparams where ea_guid = '" + oldGuid + "'"); EA.Parameter rattribute = null; SQLParameter attribute = new SQLParameter(sqlRep, result); if (attribute.ParameterGUID == "") { rattribute = parentMethod.Parameters.AddNew(attributeNode.getAttributeOrCreate("name").Value, "") as EA.Parameter; rattribute.Update(); repository.Execute("update t_operationparams set ea_guid = '" + oldGuid + "' where ea_guid = '" + rattribute.ParameterGUID + "'"); parentMethod.Parameters.Refresh(); foreach (EA.Parameter parm in parentMethod.Parameters) { if (parm.ParameterGUID == oldGuid) { return(parm); } } } return(rattribute); }
public override Serialization.MocaTree.MocaNode serializeToMocaTree() { MocaNode eClassNode = base.serializeToMocaTree(); eClassNode.Name = "CorrespondenceType"; return(eClassNode); }
public override Serialization.MocaTree.MocaNode serializeToMocaTree() { if (!isInitialized) { computeFeatures(); } MocaNode eclassNode = new MocaNode("EClass"); eclassNode.appendChildAttribute("name", this.Name); eclassNode.appendChildAttribute("isAbstract", this.isAbstract.ToString().ToLower()); eclassNode.appendChildAttribute("isInterface", this.isInterface.ToString().ToLower()); eclassNode.appendChildAttribute(Main.GuidStringName, this.EaElement.ElementGUID); eclassNode.appendChildAttribute("alias", this.Alias); MocaNode referencesNode = eclassNode.appendChildNode(EClass.ReferencesChildNodeName); MocaNode attributesNode = eclassNode.appendChildNode(EClass.AttributesChildNodeName); MocaNode operationsNode = eclassNode.appendChildNode(EClass.OperationsChildNodeName); foreach (EAttribute eAttribute in this.EAttributes) { MocaNode eAttributeNode = attributesNode.appendChildNode("EAttribute"); eAttribute.serializeToMocaTree(eAttributeNode); } foreach (EOperation eOperation in this.EOperations) { MocaNode eOperationNode = operationsNode.appendChildNode("EOperation"); eOperation.serializeToMocaTree(eOperationNode); } return(eclassNode); }
public override void deserializeFromMocaTree(Serialization.MocaTree.MocaNode actNode) { this.MethodGuid = actNode.getAttributeOrCreate("methodGuid").Value; this.MethodNameOld = actNode.getAttributeOrCreate("methodName").Value; this.MethodReturnType = actNode.getAttributeOrCreate("methodReturnType").Value; SQLMethod mt = Repository.GetMethodByGuid(this.MethodGuid); if (mt != null) { this.MethodName = mt.Name; } else { this.MethodName = MethodNameOld; } MocaNode targetNode = actNode.getChildNodeWithName("target"); this.Target = Expression.createExpression(targetNode.getAttributeOrCreate("type").Value, Repository); this.Target.deserializeFromMocaTree(targetNode); foreach (MocaNode childNode in actNode.Children) { if (childNode.Name == "ownedParameterBinding") { ParameterBinding paramBinding = new ParameterBinding(Repository); paramBinding.deserializeFromMocaTree(childNode); this.OwnedParameterBinding.Add(paramBinding); } } }
private void processTggRule(SQLElement ruleClass) { //this.exportProgressBar.invokePerformNext("exporting EClass: " + eaClass.Name); SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(ruleClass, Main.MoflonExportTreeTaggedValueName); TGGRule tggRule = new TGGRule(repository, ruleClass); tggRule.loadTreeFromTaggedValue(); MocaNode tggRuleMocaNode = new MocaNode(); tggRuleMocaNode.deserializeFromXmlTree(MocaTreeUtil.stringToXmlDocument(mocaTreeTag.Notes).DocumentElement.FirstChild as XmlElement); this.currentNode.appendChildNode(tggRuleMocaNode); tggRule.additionalAttributesDuringExport(tggRuleMocaNode); foreach (SQLElement element in ruleClass.Elements) { //handle tgg rule pattern if (element.Stereotype == TGGModelingMain.TggObjectVariableStereotype || element.Stereotype == TGGModelingMain.TggCorrespondenceStereotype) { this.currentNode = tggRuleMocaNode.getChildNodeWithName(StoryPattern.ObjectVariablesChildNodeName); processTggObjectVariable(element); } //handle sdms of tgg rule class else if (element.Stereotype == SDMModelingMain.SdmContainerStereotype) { String associatedMethodguid = EAEcoreAddin.Util.EAUtil.findTaggedValue(element, SDMModelingMain.SDMContainerAssociatedMethodTaggedValueName).Value; MocaNode operationsNode = tggRuleMocaNode.getChildNodeWithName(EClass.OperationsChildNodeName); MocaNode owningOperationNode = null; foreach (MocaNode EOperationNode in operationsNode.Children) { MocaAttribute guidAttribute = EOperationNode.getAttributeOrCreate(Main.GuidStringName); if (guidAttribute != null && guidAttribute.Value == associatedMethodguid) { owningOperationNode = EOperationNode; } } if (owningOperationNode != null) { MocaNode sdmActivityNode = this.ExportMain.ecoreExport.sdmExport.processActivity(element); owningOperationNode.appendChildNode(sdmActivityNode); } } else if (element.Stereotype == TGGModelingMain.CSPConstraintStereotype || element.Stereotype == "TGGCsp") { MocaNode cspsNode = tggRuleMocaNode.getChildNodeWithName(TGGRule.CspsChildNodeName); if (cspsNode == null) { cspsNode = tggRuleMocaNode.appendChildNode(TGGRule.CspsChildNodeName); } this.currentNode = cspsNode; processTGGCSP(element); tggRuleMocaNode.getAttributeOrCreate(TGGRule.CspSpecAttributeName).Value += element.Notes.Replace(Environment.NewLine, ""); } } }
public override Serialization.MocaTree.MocaNode serializeToMocaTree() { MocaNode ovNode = base.serializeToMocaTree(); ovNode.Name = TGGCorrespondence.CorrespondenceNodeName; return(ovNode); }
private void processTGGPackageFeatures(MocaNode ePackageMocaNode, SQLElement childClass) { if (childClass.Stereotype == TGGModelingMain.TggCorrespondenceTypeStereotype) { this.currentNode = ePackageMocaNode.getChildNodeWithName(EPackageHelper.ClassesChildNodeName); processTGGCorrespondenceType(childClass); } else if (childClass.Stereotype == TGGModelingMain.TggRuleSetStereotype) { foreach (SQLElement childElement in childClass.Elements) { processTGGPackageFeatures(ePackageMocaNode, childElement); } } else if (childClass.Stereotype == TGGModelingMain.TggRuleStereotype) { MocaNode rulesNode = ePackageMocaNode.getChildNodeWithName(TGGRulePackage.RulesChildNodeName); if (rulesNode == null) { rulesNode = ePackageMocaNode.appendChildNode(TGGRulePackage.RulesChildNodeName); } this.currentNode = rulesNode; processTggRule(childClass); } else if (childClass.Stereotype == ECOREModelingMain.EClassStereotype) { ExportMain.ecoreExport.currentNode = new MocaNode(); this.currentNode = ePackageMocaNode.getChildNodeWithName(EPackageHelper.ClassesChildNodeName); currentNode.appendChildNode(ExportMain.ecoreExport.processEClass(childClass)); } }
public MocaNode processOutermostPackage(SQLPackage outermostPackage) { this.currentNode = new MocaNode(); MocaNode outerMostPackageMocaNode = processEPackage(outermostPackage); return(outerMostPackageMocaNode); }