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, "");
}
}
}
private void writeDocumentToFile(XmlDocument docToWrite, String changesExtension)
{
String filePath = null;
String currentValue = MocaTreeUtil.xmlDocumentToString(docToWrite);
if (changesExtension != null)
{
filePath = Path.Combine(tempDirectoryPath, fileName + "." + changesExtension + ".moca.xmi");
}
else
{
filePath = Path.Combine(tempDirectoryPath, fileName + ".moca.xmi");
}
String dirName = new FileInfo(filePath).DirectoryName;
if (!(Directory.Exists(dirName)))
{
Directory.CreateDirectory(dirName);
}
if (File.Exists(filePath))
{
File.Delete(filePath);
}
File.AppendAllText(filePath, currentValue);
}
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 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);
}
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 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 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);
}
/// <summary>
/// Deserializes the TaggedValue from the tagged Object
/// </summary>
/// <returns></returns>
public Boolean loadTreeFromTaggedValue()
{
String tagNotes = "";
Object mocaTag = null;
Object objectToBeTagged = getObjectToBeTagged();
if (objectToBeTagged is SQLElement)
{
mocaTag = EAUtil.findTaggedValue(objectToBeTagged as SQLElement, Main.MoflonExportTreeTaggedValueName);
}
else if (objectToBeTagged is SQLConnector)
{
mocaTag = EAUtil.findTaggedValue(objectToBeTagged as SQLConnector, Main.MoflonExportTreeTaggedValueName);
}
else if (objectToBeTagged is SQLPackage)
{
mocaTag = EAUtil.findTaggedValue(objectToBeTagged as SQLPackage, Main.MoflonExportTreeTaggedValueName);
}
else if (objectToBeTagged is SQLMethod)
{
mocaTag = EAUtil.findTaggedValue(Repository.GetOriginalRepository().GetMethodByID((objectToBeTagged as SQLMethod).MethodID), Main.MoflonExportTreeTaggedValueName);
}
if (mocaTag is SQLTaggedValue)
{
tagNotes = (mocaTag as SQLTaggedValue).Notes;
}
else if (mocaTag is SQLConnectorTag)
{
tagNotes = (mocaTag as SQLConnectorTag).Notes;
}
else if (mocaTag is EA.MethodTag)
{
tagNotes = (mocaTag as EA.MethodTag).Notes;
}
if (tagNotes != "")
{
XmlDocument xmlDocument = MocaTreeUtil.stringToXmlDocument(tagNotes);
MocaNode emptyMocaNode = new MocaNode();
//fill mocanode from xmlElement
emptyMocaNode.deserializeFromXmlTree(xmlDocument.FirstChild.FirstChild as XmlElement);
//fill this from mocanode
try
{
deserializeFromMocaTree(emptyMocaNode);
}
catch
{
return(false);
}
return(true);
}
return(false);
}
private void processTGGCSP(SQLElement element)
{
SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(element, Main.MoflonExportTreeTaggedValueName);
if (mocaTreeTag != null)
{
MocaNode tggRuleMocaNode = new MocaNode();
tggRuleMocaNode.deserializeFromXmlTree(MocaTreeUtil.stringToXmlDocument(mocaTreeTag.Notes).DocumentElement.FirstChild as XmlElement);
this.currentNode.appendChildNode(tggRuleMocaNode);
}
}
public void processEEnum(SQLElement eaEnum)
{
SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaEnum, Main.MoflonExportTreeTaggedValueName);
if (mocaTreeTag != null)
{
MocaNode eEnumMocaNode = new MocaNode();
eEnumMocaNode.deserializeFromXmlTree(MocaTreeUtil.stringToXmlDocument(mocaTreeTag.Notes).DocumentElement.FirstChild as XmlElement);
this.currentNode.appendChildNode(eEnumMocaNode);
}
}
public void addChangesAttributesDuringExport(MocaNode pkgNode, SQLTaggedValue changesTreeTag)
{
MocaNode ePackageMocaNode = MocaTreeUtil.mocaNodeFromXmlString(changesTreeTag.Notes);
string[] expectedAttributes = { ChangesTreeConstants.ATTRIBUTE_KEY_NAME, ChangesTreeConstants.ATTRIBUTE_KEY_PREVIOUS_NAME, ChangesTreeConstants.ATTRIBUTE_KEY_PACKAGE_NAME, ChangesTreeConstants.ATTRIBUTE_KEY_PROJECT_NAME };
if (ePackageMocaNode.hasAllAttributes(new List <string>(expectedAttributes)))
{
pkgNode.appendChildAttribute("Changes::Name", ePackageMocaNode.getAttribute(ChangesTreeConstants.ATTRIBUTE_KEY_NAME).Value);
pkgNode.appendChildAttribute("Changes::PreviousName", ePackageMocaNode.getAttribute(ChangesTreeConstants.ATTRIBUTE_KEY_PREVIOUS_NAME).Value);
pkgNode.appendChildAttribute("Changes::PackageName", ePackageMocaNode.getAttribute(ChangesTreeConstants.ATTRIBUTE_KEY_PACKAGE_NAME).Value);
pkgNode.appendChildAttribute("Changes::ProjectName", ePackageMocaNode.getAttribute(ChangesTreeConstants.ATTRIBUTE_KEY_PROJECT_NAME).Value);
//pkgNode.appendChildAttribute("Changes::IsTLP", ePackageMocaNode.getAttribute("isTLP").Value);
}
}
public void processActivityEdge(SQLConnector activityEdgeEAElement)
{
SQLConnectorTag mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(activityEdgeEAElement, Main.MoflonExportTreeTaggedValueName);
ActivityEdge aEdge = new ActivityEdge(repository, activityEdgeEAElement);
Boolean valid = aEdge.loadTreeFromTaggedValue();
MocaNode activityEdgeMocaNode = new MocaNode();
activityEdgeMocaNode.deserializeFromXmlTree(MocaTreeUtil.stringToXmlDocument(mocaTreeTag.Notes).DocumentElement.FirstChild as XmlElement);
aEdge.addAttributesDuringExport(activityEdgeMocaNode);
this.currentNode.appendChildNode(activityEdgeMocaNode);
}
private MocaNode processEPackage(SQLPackage eaPackage)
{
SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaPackage, Main.MoflonExportTreeTaggedValueName);
if (mocaTreeTag != null)
{
EPackage ePackage = new EPackage(eaPackage, repository);
MocaNode ePackageMocaNode = MocaTreeUtil.mocaNodeFromXmlString(mocaTreeTag.Notes);
SQLTaggedValue changesTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaPackage, Main.MoflonChangesTreeTaggedValueName);
if (changesTreeTag != null)
{
MocaNode ePackageChangesMocaNode = MocaTreeUtil.mocaNodeFromXmlString(changesTreeTag.Notes);
if (ePackageChangesMocaNode.hasAllAttributes(new List <string>(
new string[] { ChangesTreeConstants.ATTRIBUTE_KEY_PACKAGE_NAME, ChangesTreeConstants.ATTRIBUTE_KEY_PROJECT_NAME })))
{
ePackage.addChangesAttributesDuringExport(ePackageMocaNode, changesTreeTag);
CachedPackage temp = new CachedPackage();
temp.getPackage(eaPackage.PackageGUID, repository);
temp.name = eaPackage.Name;
temp.previousName = eaPackage.Name;
temp.packageName = ePackageChangesMocaNode.getAttribute(ChangesTreeConstants.ATTRIBUTE_KEY_PACKAGE_NAME).Value;
temp.projectName = ePackageChangesMocaNode.getAttribute(ChangesTreeConstants.ATTRIBUTE_KEY_PROJECT_NAME).Value;
temp.savePackageToEATaggedValue(true);
}
}
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);
}
private MocaNode processEPackage(SQLPackage eaPackage)
{
backgroundWorker.ReportProgress(0, PersistencyUtil.computePackageUri(eaPackage, repository));
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);
int counter = 0;
foreach (SQLElement childClass in eaPackage.Elements)
{
if (!Export.showStatusBar)
{
Console.Out.WriteLine("SCALE:Export Classifier '" + childClass.Name + "' %" + counter + "/" + eaPackage.Elements.Count + "#");
}
counter++;
this.currentNode = ePackageMocaNode.getChildNodeWithName(EPackageHelper.ClassesChildNodeName);
if (childClass.Stereotype.ToLower() == ECOREModelingMain.EClassStereotype.ToLower())
{
processEClass(childClass);
}
else if (childClass.Stereotype.ToLower() == ECOREModelingMain.EDatatypeStereotype.ToLower())
{
processEDatatype(childClass);
}
else if (childClass.Stereotype.ToLower() == ECOREModelingMain.EEnumStereotype.ToLower())
{
processEEnum(childClass);
}
}
foreach (SQLPackage childPackage in eaPackage.Packages)
{
this.currentNode = ePackageMocaNode.getChildNodeWithName(EPackageHelper.PackagesChildNodeName);
processEPackage(childPackage);
}
return(ePackageMocaNode);
}
return(null);
}
internal void finalize()
{
XmlDocument xmlDoc = MocaTreeUtil.createMocaXMLDoc();
xmlDoc.DocumentElement.AppendChild(this.MocaTree.serializeToXmlTree(xmlDoc));
writeDocumentToFile(xmlDoc, null);
//track changes
XmlDocument xmlRefactorDoc = MocaTreeUtil.createMocaXMLDoc();
xmlRefactorDoc.DocumentElement.AppendChild(this.ChangesTree.serializeToXmlTree(xmlRefactorDoc));
writeDocumentToFile(xmlRefactorDoc, "changes");
ExportRunning = false;
}
public void processTggLinkVariable(SQLConnector linkVariable)
{
SQLConnectorTag mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(linkVariable, Main.MoflonExportTreeTaggedValueName);
TGGLinkVariable lv = new TGGLinkVariable(linkVariable, repository);
Boolean valid = lv.loadTreeFromTaggedValue();
MocaNode linkVariableMocaNode = new MocaNode();
linkVariableMocaNode.deserializeFromXmlTree(MocaTreeUtil.stringToXmlDocument(mocaTreeTag.Notes).DocumentElement.FirstChild as XmlElement);
lv.addAttributesDuringExport(linkVariableMocaNode);
this.currentNode.appendChildNode(linkVariableMocaNode);
}
public String getXMLDocumentString()
{
//create xml stub with a single root node
XmlDocument xmlDocStub = MocaTreeUtil.createMocaXMLDoc();
//parse this object to moca element tree
MocaNode treeElement = this.serializeToMocaTree();
//parse moca element to xmlElement tree
XmlElement serializedMocaRoot = treeElement.serializeToXmlTree(xmlDocStub);
//append new xmlElement to xmlDocument
xmlDocStub.FirstChild.AppendChild(serializedMocaRoot);
String documentString = MocaTreeUtil.xmlDocumentToString(xmlDocStub);
return(documentString);
}
public MocaNode processTggObjectVariable(SQLElement objectVariable)
{
SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(objectVariable, Main.MoflonExportTreeTaggedValueName);
ObjectVariable ov = null;
if (objectVariable.Stereotype == TGGModelingMain.TggObjectVariableStereotype)
{
ov = new TGGObjectVariable(objectVariable, repository);
}
else if (objectVariable.Stereotype == TGGModelingMain.TggCorrespondenceStereotype)
{
ov = new TGGCorrespondence(objectVariable, repository);
}
SQLElement classifier = repository.GetElementByID(objectVariable.ClassifierID);
ExportMain.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)
{
try
{
SQLElement source = repository.GetElementByID(linkVariable.ClientID);
SQLElement target = repository.GetElementByID(linkVariable.SupplierID);
if ((linkVariable.Stereotype == TGGModelingMain.TggLinkVariableStereotype || linkVariable.Type == Main.EAAssociationType) && linkVariable.ClientID == objectVariable.ElementID)
{
this.currentNode = ovMocaNode.getChildNodeWithName(ObjectVariable.OutgoingLinksNodeName);
processTggLinkVariable(linkVariable);
}
}
catch
{
}
}
return(ovMocaNode);
}
private void buttonImportCSP_Click(object sender, EventArgs e)
{
checkForFunctions();
if (activateExportImportCSPButton)
{
String pathToWrite = Path.GetDirectoryName(repository.ConnectionString);
OpenFileDialog dialog = new OpenFileDialog();
dialog.AddExtension = true;
dialog.DefaultExt = "txt";
dialog.InitialDirectory = pathToWrite;
dialog.Filter = "Text files (*.txt)|*.txt|All files (*.*)|*.*";
dialog.FileName = "csptemp.txt";
if (dialog.ShowDialog() == DialogResult.OK)
{
TGG tggPackage = new TGG(repository, repository.GetTreeSelectedPackage());
tggPackage.loadTreeFromTaggedValue();
String fileContent = File.ReadAllText(dialog.FileName);
MocaNode dummyParent = MocaTreeUtil.mocaNodeFromXmlString(fileContent);
foreach (MocaNode cspNode in dummyParent.Children)
{
CSPConstraint constraint = new CSPConstraint();
constraint.deserializeFromMocaTree(cspNode);
Boolean alreadyIn = false;
foreach (CSPConstraint existingCSP in tggPackage.Constraints)
{
if (existingCSP.Name == constraint.Name)
{
alreadyIn = true;
break;
}
}
if (!alreadyIn)
{
tggPackage.Constraints.Add(constraint);
}
}
tggPackage.saveTreeToEATaggedValue(false);
}
}
}
public void processTGGCorrespondenceType(SQLElement eaClass)
{
SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaClass, Main.MoflonExportTreeTaggedValueName);
TGGCorrespondenceType tggCorrType = new TGGCorrespondenceType(eaClass, repository);
tggCorrType.loadTreeFromTaggedValue();
MocaNode eClassMocaNode = new MocaNode();
eClassMocaNode.deserializeFromXmlTree(MocaTreeUtil.stringToXmlDocument(mocaTreeTag.Notes).DocumentElement.FirstChild as XmlElement);
tggCorrType.addMocaAttributesDuringExport(eClassMocaNode);
this.currentNode.appendChildNode(eClassMocaNode);
foreach (SQLConnector ereference in eaClass.Connectors)
{
if (ereference.Type == Main.EAAssociationType)
{
MocaNode referencesNode = eClassMocaNode.getChildNodeWithName(EClass.ReferencesChildNodeName);
if (ereference.ClientID != eaClass.ElementID && ereference.ClientEnd.IsNavigable)
{
this.currentNode = referencesNode;
processTggEReference(ereference, ereference.ClientEnd.End);
}
else if (ereference.SupplierID != eaClass.ElementID && ereference.SupplierEnd.IsNavigable)
{
this.currentNode = referencesNode;
processTggEReference(ereference, ereference.SupplierEnd.End);
}
if (ereference.SupplierID == eaClass.ElementID && ereference.ClientID == eaClass.ElementID && ereference.SupplierEnd.IsNavigable)
{
this.currentNode = referencesNode;
processTggEReference(ereference, ereference.SupplierEnd.End);
}
if (ereference.SupplierID == eaClass.ElementID && ereference.ClientID == eaClass.ElementID && ereference.ClientEnd.IsNavigable)
{
this.currentNode = referencesNode;
processTggEReference(ereference, ereference.ClientEnd.End);
}
}
}
}
public MocaNode processTggOutermostPackage(SQLPackage tggOutermostPackage)
{
backgroundWorker.ReportProgress(0, PersistencyUtil.computePackageUri(tggOutermostPackage, repository));
this.currentNode = new MocaNode();
SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(tggOutermostPackage, Main.MoflonExportTreeTaggedValueName);
TGG tgg = new TGG(repository, tggOutermostPackage);
tgg.loadTreeFromTaggedValue();
XmlDocument xmlDoc = MocaTreeUtil.stringToXmlDocument(mocaTreeTag.Notes);
MocaNode ePackageMocaNode = new MocaNode();
ePackageMocaNode.deserializeFromXmlTree(xmlDoc.DocumentElement.FirstChild as XmlElement);
tgg.addAttributesDuringExport(ePackageMocaNode);
this.currentNode.appendChildNode(ePackageMocaNode);
foreach (SQLPackage childPackage in tggOutermostPackage.Packages)
{
this.currentNode = ePackageMocaNode.getChildNodeWithName(EPackageHelper.PackagesChildNodeName);
processTggPackage(childPackage);
}
foreach (SQLElement childClass in tggOutermostPackage.Elements)
{
processTGGPackageFeatures(ePackageMocaNode, childClass);
}
SQLTaggedValue moflonExportTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(tggOutermostPackage, MetamodelHelper.MoflonExportTaggedValueName);
if (moflonExportTag != null)
{
ePackageMocaNode.appendChildAttribute(MetamodelHelper.MoflonExportTaggedValueName, moflonExportTag.Value);
}
else
{
ePackageMocaNode.appendChildAttribute(MetamodelHelper.MoflonExportTaggedValueName, "false");
}
return(ePackageMocaNode);
}
private MocaNode processTggPackage(SQLPackage eaPackage)
{
backgroundWorker.ReportProgress(0, PersistencyUtil.computePackageUri(eaPackage, repository));
EPackage ePackage = new EPackage(eaPackage, repository);
if (eaPackage.Element.Stereotype == TGGModelingMain.TggRulePackageStereotype || eaPackage.Name == "Rules")
{
ePackage = new TGGRulePackage(eaPackage, repository);
}
ePackage.loadTreeFromTaggedValue();
SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaPackage, Main.MoflonExportTreeTaggedValueName);
XmlDocument xmlDoc = MocaTreeUtil.stringToXmlDocument(mocaTreeTag.Notes);
MocaNode ePackageMocaNode = new MocaNode();
ePackageMocaNode.deserializeFromXmlTree(xmlDoc.DocumentElement.FirstChild as XmlElement);
ePackage.addAttributesDuringExport(ePackageMocaNode);
this.currentNode.appendChildNode(ePackageMocaNode);
foreach (SQLPackage childPackage in eaPackage.Packages)
{
this.currentNode = ePackageMocaNode.getChildNodeWithName(EPackageHelper.PackagesChildNodeName);
processTggPackage(childPackage);
}
foreach (SQLElement childClass in eaPackage.Elements)
{
processTGGPackageFeatures(ePackageMocaNode, childClass);
}
return(ePackageMocaNode);
}
public MocaNode processActivity(SQLElement sdmContainerClass)
{
SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(sdmContainerClass, Main.MoflonExportTreeTaggedValueName);
Activity activity = new Activity(sdmContainerClass, repository);
Boolean valid = activity.loadTreeFromTaggedValue();
MocaNode activityMocaNode = new MocaNode();
activityMocaNode.deserializeFromXmlTree(MocaTreeUtil.stringToXmlDocument(mocaTreeTag.Notes).DocumentElement.FirstChild as XmlElement);
this.currentNode = activityMocaNode;
foreach (SQLElement activityNode in sdmContainerClass.Elements)
{
if (activityNode.Type == Main.EAActivityType || activityNode.Type == Main.EAStateNodeType)
{
this.currentNode = activityMocaNode;
processActivityNode(activityNode);
}
}
return(activityMocaNode);
}
private void buttonExportCsp_Click(object sender, EventArgs e)
{
checkForFunctions();
if (activateExportImportCSPButton)
{
String cspXmlString = "";
String pathToWrite = Path.GetDirectoryName(repository.ConnectionString);
SaveFileDialog dialog = new SaveFileDialog();
dialog.AddExtension = true;
dialog.DefaultExt = "txt";
dialog.InitialDirectory = pathToWrite;
dialog.Filter = "Text files (*.txt)|*.txt|All files (*.*)|*.*";
dialog.FileName = "csptemp.txt";
if (dialog.ShowDialog() == DialogResult.OK)
{
TGG tggPackage = new TGG(repository, repository.GetTreeSelectedPackage());
tggPackage.loadTreeFromTaggedValue();
MocaNode dummyNode = new MocaNode();
foreach (CSPConstraint constraint in tggPackage.Constraints)
{
if (constraint.UserDefined)
{
dummyNode.Children.Add(constraint.serializeToMocaTree(new MocaNode("CSPConstraint")));
}
}
cspXmlString = MocaTreeUtil.mocaNodeToString(dummyNode);
pathToWrite = dialog.FileName;
File.WriteAllText(pathToWrite, cspXmlString);
MessageBox.Show("User defined CSPs are exported to path: " + pathToWrite);
}
}
}
/// <summary>
/// Serializes the current Object 1. to MocaTree and 2. to XmlDocument and saves the XmlDocument
/// represented as String to a TaggedValue. Last some EA GUI stuff is done which is used to make sure that
/// the visualization in EA works correctly.
/// </summary>
public void saveTreeToEATaggedValue(Boolean updateEaGui)
{
String documentString = "";
if (!this.isIgnored())
{
//create xml stub with a single root node
XmlDocument xmlDocStub = MocaTreeUtil.createMocaXMLDoc();
//parse this object to moca element tree
MocaNode treeElement = this.serializeToMocaTree();
//parse moca element to xmlElement tree
XmlElement serializedMocaRoot = treeElement.serializeToXmlTree(xmlDocStub);
//append new xmlElement to xmlDocument
xmlDocStub.FirstChild.AppendChild(serializedMocaRoot);
documentString = MocaTreeUtil.xmlDocumentToString(xmlDocStub);
}
if (Import.MainImport.ImportBusy)
{
foreach (String oldGuid in Import.MainImport.getInstance(Repository, null).OldGuidToNewGuid.Keys)
{
documentString = documentString.Replace(oldGuid, Import.MainImport.getInstance(Repository, null).OldGuidToNewGuid[oldGuid]);
}
}
if (!isLocked())
{
EAEcoreAddin.Util.EAUtil.setTaggedValueNotes(Repository, getObjectToBeTagged(), Main.MoflonExportTreeTaggedValueName, documentString);
if (updateEaGui)
{
doEaGuiStuff();
}
}
refreshSQLObject();
}
public MocaNode processEClass(SQLElement eaClass)
{
//this.exportProgressBar.invokePerformNext("Exporting EClass: " + eaClass.Name);
SQLTaggedValue changesTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaClass, Main.MoflonChangesTreeTaggedValueName);
SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaClass, Main.MoflonExportTreeTaggedValueName);
if (mocaTreeTag != null)
{
EClass eClass = new EClass(eaClass, repository);
eClass.loadTreeFromTaggedValue();
MocaNode eClassMocaNode = MocaTreeUtil.mocaNodeFromXmlString(mocaTreeTag.Notes);
eClass.addMocaAttributesDuringExport(eClassMocaNode);
if (changesTreeTag != null)
{
MocaNode eClassChangesNode = MocaTreeUtil.mocaNodeFromXmlString(changesTreeTag.Notes);
eClass.addMocaAttributesDuringExport(eClassChangesNode);
}
//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);
//process SDM Container Objects
int counter = 0;
foreach (SQLElement possibleSDMContainer in eaClass.Elements)
{
if (possibleSDMContainer.Stereotype == SDMModelingMain.SdmContainerStereotype || possibleSDMContainer.Stereotype == "SDM_Container")
{
String associatedMethodguid = EAEcoreAddin.Util.EAUtil.findTaggedValue(possibleSDMContainer, SDMModelingMain.SDMContainerAssociatedMethodTaggedValueName).Value;
MocaNode operationsNode = eClassMocaNode.getChildNodeWithName(EClass.OperationsChildNodeName);
MocaNode owningOperationNode = null;
if (!Export.showStatusBar)
{
Console.Out.WriteLine("SCALE:Export SDM '" + possibleSDMContainer.Name + "' %" + counter + "/" + eaClass.Elements.Count + "#");
}
counter++;
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.sdmExport.processActivity(possibleSDMContainer);
owningOperationNode.appendChildNode(sdmActivityNode);
}
}
}
foreach (SQLAttribute element in eaClass.Attributes)
{
string t = element.Type;
int cid = element.ClassifierID;
SQLElement typeElement = repository.GetElementByIDNullable(cid);
Export.computeAndAddToDependencies(repository, typeElement);
}
counter = 0;
foreach (SQLConnector ereference in eaClass.Connectors)
{
if (ereference.Type == Main.EAAssociationType)
{
if (!Export.showStatusBar)
{
Console.Out.WriteLine("SCALE:Export EReference '" + ereference.Name + "' %" + counter + "/" + eaClass.Connectors.Count + "#");
}
counter++;
MocaNode referencesNode = eClassMocaNode.getChildNodeWithName(EClass.ReferencesChildNodeName);
if (ereference.ClientID != eaClass.ElementID && ereference.ClientEnd.IsNavigable)
{
this.currentNode = referencesNode;
processEReference(ereference, ereference.ClientEnd.End);
}
else if (ereference.SupplierID != eaClass.ElementID && ereference.SupplierEnd.IsNavigable)
{
this.currentNode = referencesNode;
processEReference(ereference, ereference.SupplierEnd.End);
}
if (ereference.SupplierID == eaClass.ElementID && ereference.ClientID == eaClass.ElementID && ereference.SupplierEnd.IsNavigable)
{
this.currentNode = referencesNode;
processEReference(ereference, ereference.SupplierEnd.End);
}
if (ereference.SupplierID == eaClass.ElementID && ereference.ClientID == eaClass.ElementID && ereference.ClientEnd.IsNavigable)
{
this.currentNode = referencesNode;
processEReference(ereference, ereference.ClientEnd.End);
}
}
}
return(eClassMocaNode);
}
return(null);
}
public void processActivityNode(SQLElement activityNodeEAElement)
{
if (Serialization.MocaTaggableElement.isIgnored(activityNodeEAElement))
{
return;
}
ActivityNode actNode = null;
if (activityNodeEAElement.Stereotype == "StoryNode" || activityNodeEAElement.Elements.Count > 0 || (activityNodeEAElement.Elements.Count == 0 && activityNodeEAElement.Notes == "" && activityNodeEAElement.Subtype != 100 && activityNodeEAElement.Subtype != 101))
{
actNode = new StoryNode(repository, activityNodeEAElement);
}
else if (activityNodeEAElement.Stereotype == "StopNode" || activityNodeEAElement.Subtype == 101)
{
actNode = new StopNode(repository, activityNodeEAElement);
}
else if (activityNodeEAElement.Stereotype == "StartNode" || activityNodeEAElement.Subtype == 100)
{
actNode = new StartNode(repository, activityNodeEAElement);
}
else if (activityNodeEAElement.Stereotype == "StatementNode" || (activityNodeEAElement.Elements.Count == 0 && activityNodeEAElement.Notes != ""))
{
actNode = new StatementNode(repository, activityNodeEAElement);
}
Boolean valid = actNode.loadTreeFromTaggedValue();
SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(activityNodeEAElement, Main.MoflonExportTreeTaggedValueName);
MocaNode activityNodeMocaNode = new MocaNode();
activityNodeMocaNode.deserializeFromXmlTree(MocaTreeUtil.stringToXmlDocument(mocaTreeTag.Notes).DocumentElement.FirstChild as XmlElement);
this.currentNode.appendChildNode(activityNodeMocaNode);
foreach (SQLConnector activityEdge in activityNodeEAElement.Connectors)
{
if ((activityEdge.Stereotype == SDMModelingMain.ActivityEdgeStereotype || activityEdge.Stereotype == "") && activityEdge.Type == "ControlFlow" && activityEdge.ClientID == activityNodeEAElement.ElementID)
{
this.currentNode = activityNodeMocaNode.getChildNodeWithName(ActivityNode.OutgoingTransitionsNodeName);
processActivityEdge(activityEdge);
}
}
foreach (SQLElement storyNodeChild in activityNodeEAElement.Elements)
{
if (storyNodeChild.Stereotype == SDMModelingMain.ObjectVariableStereotype || storyNodeChild.Stereotype == "SDM_Object")
{
this.currentNode = activityNodeMocaNode.getChildNodeWithName(StoryPattern.ObjectVariablesChildNodeName);
processObjectVariable(storyNodeChild);
}
else if (storyNodeChild.Stereotype == SDMModelingMain.CSPInstanceStereotype)
{
this.currentNode = activityNodeMocaNode.getChildNodeWithName("AttributeConstraints");
if (currentNode == null)
{
this.currentNode = activityNodeMocaNode.appendChildNode("AttributeConstraints");
}
MocaNode cspNode = currentNode.appendChildNode("AttributeConstraint");
cspNode.appendChildAttribute("constraintSpec", storyNodeChild.Notes);
SQLTaggedValue nacIndexTag = EAUtil.findTaggedValue(storyNodeChild, "nacIndex");
if (nacIndexTag != null)
{
String nacIndex = nacIndexTag.Value;
cspNode.appendChildAttribute("nacIndex", nacIndex != "" ? nacIndex : "-1");
}
}
}
}
