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