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);
}
public override List <FirstObject> getFirstObjects(SQLElement elementToSearch, SQLRepository repository)
{
List <FirstObject> targetParameters = new List <FirstObject>();
SQLMethod associatedMethod = null;
if (elementToSearch.Stereotype == SDMModelingMain.SdmContainerStereotype)
{
SQLTaggedValue assoMethodTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(elementToSearch, SDMModelingMain.SDMContainerAssociatedMethodTaggedValueName);
associatedMethod = repository.GetMethodByGuid(assoMethodTag.Value);
}
else if (elementToSearch.Stereotype == TGGModelingMain.TggRuleStereotype)
{
if (elementToSearch.Methods.Count > 0)
{
associatedMethod = elementToSearch.Methods.GetAt(0);
}
}
if (associatedMethod != null)
{
foreach (SQLParameter parameter in associatedMethod.Parameters)
{
targetParameters.Add(new FirstObject(parameter));
}
}
targetParameters.Sort(new EAObjectIComparer());
return(targetParameters);
}
public static bool openSelectedMethodSDM(EA.Diagram actDiag, SQLMethod meth, SQLRepository sqlRepository, out SQLElement methParent, out SQLElement container)
{
SQLTaggedValue aTag = null;
methParent = sqlRepository.GetElementByID(meth.ParentID);
container = null;
foreach (SQLElement sdmContainer in methParent.Elements)
{
aTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(sdmContainer, SDMModelingMain.SDMContainerAssociatedMethodTaggedValueName);
if (aTag != null)
{
if (aTag.Value == meth.MethodGUID.ToString())
{
container = sdmContainer;
break;
}
}
}
SQLDiagram sdmDiagg = null;
if (container != null)
{
foreach (SQLDiagram sdmDiag in container.Diagrams)
{
sdmDiagg = sdmDiag;
Navigator.addAnchorEntry(sdmDiag.DiagramID, actDiag.DiagramID);
sqlRepository.OpenDiagram(sdmDiag.DiagramID);
setAnchorElementTags(sqlRepository, actDiag, container);
return(true);
}
}
return(false);
}
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 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);
}
}
}
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);
}
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);
}
private void setDefaultAppearance()
{
txtName.Text = activityTabsForm.ActivityNode.Name;
comboTypes.comboBoxFromActivityNodeType(activityTabsForm.ActivityNode);
SQLTaggedValue extractedTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(activityTabsForm.ActivityNode.ActivityNodeEAElement, Main.MoflonExtractedStoryPatternTaggedValueName);
if (extractedTag == null)
{
buttonEvacuate.Text = "Extract Story Pattern";
evacuated = Main.FalseValue;
}
else
{
evacuated = extractedTag.Value;
if (evacuated == Main.FalseValue)
{
buttonEvacuate.Text = "Extract Story Pattern";
}
if (evacuated == Main.TrueValue)
{
buttonEvacuate.Text = "Embed Story Pattern";
}
}
}
protected void setDefaultValueIfNecessary(String tagName)
{
SQLTaggedValue tag = EAUtil.findTaggedValue(package.EaPackage, tagName);
if (tag == null)
{
EAUtil.setTaggedValue(package.Repository, package.EaPackage.getRealPackage(), tagName, DEFAULT_VALUE_PLACEHOLDER);
}
}
private static void handleObsoleteTaggedValue(SQLPackage eaPackage, List <String> results, String tag)
{
SQLTaggedValue validationFilter = EAUtil.findTaggedValue(eaPackage, tag);
if (validationFilter != null)
{
results.Add("The tagged value " + tag + " is obsolete and should be deleted or renamed appropriately.");
}
}
public static bool isIgnored(SQLElement taggedObject)
{
SQLTaggedValue taggedValue = EAUtil.findTaggedValue(taggedObject, IGNORED_TAG_NAME);
if (taggedValue != null && "true".Equals(taggedValue.Value))
{
return(true);
}
return(false);
}
public static string setOvMethodCallExpressionGui(ObjectVariable ov)
{
SQLTaggedValue mceVisTag = EAUtil.findTaggedValue(ov.sqlElement, ObjectVariable.MceVisualizationTaggedValueName);
Expression BindingExpression = ov.BindingExpression;
if (BindingExpression != null)
{
deletePossibleBindingConnectors(ov.sqlElement.getRealElement());
if (BindingExpression is MethodCallExpression)
{
var mcE = BindingExpression as MethodCallExpression;
ObjectVariableExpression firstOvExpression = null;
if (mcE.OwnedParameterBinding.Count == 1 && (mceVisTag == null || mceVisTag.Value == "true"))
{
foreach (ParameterBinding paramBinding in mcE.OwnedParameterBinding)
{
if (paramBinding.ValueExpression is ObjectVariableExpression)
{
firstOvExpression = paramBinding.ValueExpression as ObjectVariableExpression;
}
}
if (firstOvExpression != null)
{
EA.Element firstOvEaElement = ov.Repository.GetOriginalRepository().GetElementByGuid(firstOvExpression.ObjectVariableGUID);
if (firstOvEaElement.ParentID == ov.sqlElement.ParentID)
{
EA.Connector bindingLink = firstOvEaElement.Connectors.AddNew("", Main.EADependencyType) as EA.Connector;
bindingLink.Stereotype = SDMModelingMain.BindingExpressionLinkStereotype;
bindingLink.Name = mcE.Target + "." + mcE.MethodName;
bindingLink.SupplierID = ov.sqlElement.ElementID;
bindingLink.Update();
EA.Element realElement = ov.sqlElement.getRealElement();
realElement.Connectors.Refresh();
realElement.Notes = "";
realElement.Update();
EAUtil.setTaggedValue(ov.Repository, realElement, ObjectVariable.BindingExpressionOutputTaggedValueName, "");
return("");
}
}
}
}
return(BindingExpression.ToString());
}
return("");
}
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);
}
}
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);
}
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);
}
}
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);
}
public override List <String> doRule(SQLMethod eaMethod, SQLRepository repository)
{
SQLElement parent = repository.GetElementByID(eaMethod.ParentID);
List <String> results = new List <string>();
if (parent.Stereotype == ECOREModelingMain.EClassStereotype)
{
foreach (SQLElement sdmContainer in parent.Elements)
{
if (sdmContainer.Stereotype == SDMModelingMain.SdmContainerStereotype)
{
SQLTaggedValue associatedTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(sdmContainer, SDMModelingMain.SDMContainerAssociatedMethodTaggedValueName);
if (associatedTag != null)
{
String associatedTagValue = associatedTag.Value;
if (associatedTagValue == eaMethod.MethodGUID)
{
foreach (SQLElement aNode in sdmContainer.Elements)
{
if (aNode.Stereotype == SDMModelingMain.StartNodeStereotype)
{
String parameters = "";
foreach (SQLParameter param in eaMethod.Parameters)
{
parameters += param.Name + ": " + param.Type + ", ";
}
if (parameters.Length > 0)
{
parameters = parameters.Substring(0, parameters.Length - 2);
}
String nameShouldBe = parent.Name + "::" + eaMethod.Name + " (" + parameters + "): " + eaMethod.ReturnType.ToString();
bool equal = nameShouldBe.StartsWith(aNode.Name);
if (!equal)
{
results.Add("SDM Container, StartNode, and Diagram name should correspond to Method name");
}
}
}
}
}
}
}
}
return(results);
}
public static SQLTaggedValue findTaggedValue(SQLElement element, String name)
{
SQLTaggedValue aTag = null;
if (element != null)
{
element.TaggedValues.Refresh();
foreach (SQLTaggedValue aTaggi in element.TaggedValues)
{
if (aTaggi.Name == name)
{
aTag = aTaggi;
}
}
}
return(aTag);
}
private string computeValidatedAttribute()
{
SQLTaggedValue validatedTag = EAUtil.findTaggedValue(package.EaPackage, MoflonValidatedTaggedValueName);
if (validatedTag != null)
{
if (validatedTag.Value.Equals(DEFAULT_VALUE_PLACEHOLDER))
{
return("false");
}
return(validatedTag.Value);
}
else
{
return("false");
}
}
public override List <string> doRule(SQLWrapperClasses.SQLElement sqlElement, SQLWrapperClasses.SQLRepository sqlRepository)
{
var result = new List <String>();
if (sqlElement.Stereotype == SDMModelingMain.ObjectVariableStereotype || sqlElement.Stereotype == TGGModelingMain.TggObjectVariableStereotype)
{
SQLTaggedValue tag = EAUtil.findTaggedValue(sqlElement, ObjectVariable.BindingSemanticsTaggedValueName);
if (tag != null)
{
if (tag.Value.ToLower() == "optional")
{
result.Add("Optional ist not supported anymore");
}
}
}
return(result);
}
private string computeExportAttribute()
{
SQLTaggedValue exportTag = EAUtil.findTaggedValue(package.EaPackage, MoflonExportTaggedValueName);
if (exportTag != null)
{
if (exportTag.Value.Equals(DEFAULT_VALUE_PLACEHOLDER))
{
return("true");
}
return(exportTag.Value);
}
else
{
return("true");
}
}
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);
}
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 override List <FirstObject> getFirstObjects(SQLElement elementToSearch, SQLRepository repository)
{
EditorAttributeValueExpression eAvExpression = new EditorAttributeValueExpression();
List <FirstObject> targetObjectVariables = eAvExpression.getFirstObjects(elementToSearch, repository);
//add parameters of associatedMethod
SQLMethod associatedMethod = null;
if (elementToSearch.Stereotype == SDMModelingMain.SdmContainerStereotype)
{
SQLTaggedValue assoMethodTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(elementToSearch, SDMModelingMain.SDMContainerAssociatedMethodTaggedValueName);
associatedMethod = repository.GetMethodByGuid(assoMethodTag.Value);
}
else if (elementToSearch.Stereotype == TGGModelingMain.TggRuleStereotype)
{
associatedMethod = elementToSearch.Methods.GetAt(0);
}
if (associatedMethod != null)
{
foreach (SQLParameter parameter in associatedMethod.Parameters)
{
if (parameter.ClassifierID != "0")
{
Boolean alreadyIn = false;
foreach (Object searchTarget in targetObjectVariables)
{
if (searchTarget is SQLElement)
{
if ((searchTarget as SQLElement).Name == parameter.Name)
{
alreadyIn = true;
}
}
}
if (!alreadyIn)
{
targetObjectVariables.Add(new FirstObject(parameter));
}
}
}
}
return(targetObjectVariables);
}
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);
}
protected String computeName()
{
SQLTaggedValue customProjectName = EAEcoreAddin.Util.EAUtil.findTaggedValue(package.EaPackage, MoflonCustomNameTaggedValueName);
if (customProjectName != null)
{
String value = customProjectName.Value;
//use default
if (value.Equals(DEFAULT_VALUE_PLACEHOLDER))
{
return(package.EaPackage.getRealPackage().Name);
}
//otherwise custom value
return(value);
}
else
{
return(package.EaPackage.getRealPackage().Name);
}
}
private string computePluginID()
{
SQLTaggedValue customPluginID = EAEcoreAddin.Util.EAUtil.findTaggedValue(package.EaPackage, MoflonCustomPluginIDTaggedValueName);
if (customPluginID != null)
{
String value = customPluginID.Value;
//use default
if (value.Equals(DEFAULT_VALUE_PLACEHOLDER))
{
return(computeName());
}
//otherwise custom value
return(value);
}
else
{
return(computeName());
}
}
