public override Serialization.MocaTree.MocaNode serializeToMocaTree(MocaNode actNode)
{
actNode.appendChildAttribute("attributeName", this.AttributeName);
actNode.appendChildAttribute("attributeGuid", this.AttributeGUID);
MocaNode valueExpNode = actNode.appendChildNode("valueExpression");
this.ValueExpression.serializeToMocaTree(valueExpNode);
return(actNode);
}
public override Serialization.MocaTree.MocaNode serializeToMocaTree()
{
MocaNode tggNode = base.serializeToMocaTree();
tggNode.Name = "TGG";
MocaNode domainsNode = tggNode.appendChildNode("domains");
MocaNode metamodelsNode = tggNode.appendChildNode("metamodels");
foreach (Metamodel metamodel in this.Metamodels)
{
MocaNode metamodelNode = metamodelsNode.appendChildNode("Metamodel");
metamodel.serializeToMocaTree(metamodelNode);
}
foreach (Domain domain in this.Domains)
{
MocaNode domainNode = domainsNode.appendChildNode("Domain");
domain.serializeToMocaTree(domainNode);
}
this.Constraints.Sort(new CSPConstraintComparer());
MocaNode constraintsNode = tggNode.appendChildNode(ConstraintsChildNodeName);
MocaNode declarationsNode = constraintsNode.appendChildNode(DeclarationsChildNodeName);
MocaNode constraintInstancesNode = constraintsNode.appendChildNode(ConstraintInstancesChildNodeName);
//only persist user defined constraints
foreach (CSPConstraint constr in this.Constraints)
{
if (constr.UserDefined)
{
MocaNode constraintNode = declarationsNode.appendChildNode("");
constr.serializeToMocaTree(constraintNode);
}
}
return(tggNode);
}
public override Serialization.MocaTree.MocaNode serializeToMocaTree()
{
MocaNode statementNode = base.serializeToMocaTree();
statementNode.appendChildAttribute("type", "statement");
if (this.StatementExpression != null)
{
MocaNode stat = statementNode.appendChildNode("statementExpression");
this.StatementExpression.serializeToMocaTree(stat);
}
return(statementNode);
}
public override Serialization.MocaTree.MocaNode serializeToMocaTree()
{
MocaNode stopNode = base.serializeToMocaTree();
stopNode.appendChildAttribute("type", "stop");
if (this.ReturnValue != null)
{
MocaNode ret = stopNode.appendChildNode("returnValue");
this.ReturnValue.serializeToMocaTree(ret);
Name = ReturnValue.ToString();
}
return(stopNode);
}
public override Serialization.MocaTree.MocaNode serializeToMocaTree(MocaNode actNode)
{
MocaNode valueExpressionNode = actNode.appendChildNode("valueExpression");
if (this.ValueExpression != null)
{
this.ValueExpression.serializeToMocaTree(valueExpressionNode);
}
actNode.appendChildAttribute("parameterGuid", this.ParameterGuid);
actNode.appendChildAttribute("parameterType", this.ParameterType);
return(actNode);
}
public override Serialization.MocaTree.MocaNode serializeToMocaTree(Serialization.MocaTree.MocaNode actNode)
{
actNode.appendChildAttribute("constraintName", constraintName);
MocaNode exprNode = actNode.appendChildNode("expressions");
foreach (Expression expr in typedInExpressions)
{
MocaNode expressionNode = exprNode.appendChildNode("Expression");
expr.serializeToMocaTree(expressionNode);
}
return(actNode);
}
public override Serialization.MocaTree.MocaNode serializeToMocaTree()
{
MocaNode constraintNode = new MocaNode("ConstraintInstance");
MocaNode entries = constraintNode.appendChildNode("entries");
foreach (CSPInstanceEntry createdEntry in createdEntries)
{
entries.appendChildNode(createdEntry.serializeToMocaTree(new MocaNode("Entry")));
}
return(constraintNode);
}
public override Serialization.MocaTree.MocaNode serializeToMocaTree(MocaNode actNode)
{
actNode.appendChildAttribute("name", this.Name);
MocaNode parametersNode = actNode.appendChildNode(EOperation.ParametersChildNodeName);
foreach (EParameter eParameter in this.EParameters)
{
MocaNode eParameterNode = parametersNode.appendChildNode("EParameter");
eParameter.serializeToMocaTree(eParameterNode);
}
actNode.appendChildAttribute(Main.GuidStringName, this.EaMethod.MethodGUID);
actNode.appendChildAttribute("typeGuid", this.typeGuid);
actNode.appendChildAttribute("returnType", this.returnType);
return(actNode);
}
public override Serialization.MocaTree.MocaNode serializeToMocaTree()
{
MocaNode eEnumNode = new MocaNode("EEnum");
eEnumNode.appendChildAttribute("name", this.eaEEnumElement.Name);
eEnumNode.appendChildAttribute(Main.GuidStringName, this.eaEEnumElement.ElementGUID);
MocaNode eLiteralsNode = eEnumNode.appendChildNode("literals");
foreach (EEnumLiteral literal in this.Literals)
{
MocaNode eLiteralNode = eLiteralsNode.appendChildNode("EEnumLiteral");
literal.serializeToMocaTree(eLiteralNode);
}
return(eEnumNode);
}
public override Serialization.MocaTree.MocaNode serializeToMocaTree()
{
MocaNode mocaNode = new MocaNode("ObjectVariable");
mocaNode.appendChildAttribute(Main.GuidStringName, this.sqlElement.ElementGUID);
if (this.Classifier != null)
{
mocaNode.appendChildAttribute("typeGuid", this.Classifier.EaElement.ElementGUID);
}
else
{
mocaNode.appendChildAttribute("typeGuid", "");
}
mocaNode.appendChildAttribute(BindingStateTaggedValueName, this.BindingState.ToString().ToLower());
mocaNode.appendChildAttribute(BindingOperatorTaggedValueName, this.BindingOperator.ToString().ToLower());
mocaNode.appendChildAttribute("name", this.Name);
mocaNode.appendChildAttribute(BindingSemanticsTaggedValueName, this.BindingSemantics.ToString().ToLower());
mocaNode.appendChildAttribute(NacIndexTaggedValueName, NacIndex.ToString());
MocaNode constraintsNode = mocaNode.appendChildNode("constraints");
MocaNode assignmentsNode = mocaNode.appendChildNode("attributeAssignments");
mocaNode.appendChildNode(ObjectVariable.OutgoingLinksNodeName);
foreach (Constraint constraint in this.Constraints)
{
MocaNode constNode = constraintsNode.appendChildNode("constraint");
constraint.serializeToMocaTree(constNode);
}
foreach (AttributeAssignment attrAssignment in this.AttributeAssignments)
{
attrAssignment.OvName = this.Name;
MocaNode attANode = assignmentsNode.appendChildNode("attributeAssignment");
attrAssignment.serializeToMocaTree(attANode);
}
if (this.BindingExpression != null)
{
MocaNode bindNode = mocaNode.appendChildNode("bindingExpression");
this.BindingExpression.serializeToMocaTree(bindNode);
}
return(mocaNode);
}
internal void enhanceMetamodelNodeWithDependencies(SQLPackage outermostPackage, MocaNode outermostPackageNode)
{
var dependencyList = dependencies[outermostPackage.Name];
MocaNode dependenciesNode = outermostPackageNode.appendChildNode("dependencies");
if (dependencyList.Count != 0)
{
int counter = 0;
foreach (String dependency in dependencyList)
{
MetamodelHelper mmHelper = packageNameToEPackage[dependency].helper as MetamodelHelper;
if (!showStatusBar)
{
Console.Out.WriteLine("SCALE:Export Dependency '" + mmHelper.pluginID + "' %" + counter + "/" + dependencyList.Count + "#");
}
dependenciesNode.appendChildNode(mmHelper.pluginID);
counter++;
}
}
}
public override void addAttributesDuringExport(MocaNode pkgNode)
{
base.addAttributesDuringExport(pkgNode);
List <CSPConstraint> tempList = new List <CSPConstraint>();
CSPUtil.addDefaultConstraints(tempList);
MocaNode constraintRootNode = pkgNode.getChildNodeWithName(ConstraintsChildNodeName);
if (constraintRootNode != null)
{
MocaNode declarationsRootNode = constraintRootNode.getChildNodeWithName(DeclarationsChildNodeName);
if (declarationsRootNode != null)
{
foreach (CSPConstraint constr in tempList)
{
MocaNode constraintNode = declarationsRootNode.appendChildNode("");
constr.serializeToMocaTree(constraintNode);
}
}
}
}
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");
}
}
}
}
public void importERef(SQLElement parent, MocaNode referencesNode)
{
foreach (MocaNode refNode in referencesNode.Children)
{
String refGuid = refNode.getAttributeOrCreate(Main.GuidStringName).Value;
String oppositeGuid = refNode.getAttributeOrCreate("oppositeGuid").Value;
bool containment = refNode.getAttributeOrCreate("containment").Value == "true";
bool hasOpposite = oppositeGuid != "";
SQLElement client = parent;
String supGuid = refNode.getAttributeOrCreate("typeGuid").Value;
EA.Connector con = null;
if (MainImport.getInstance().ElementGuidToElement.ContainsKey(supGuid))
{
EA.Element supplier = MainImport.getInstance().ElementGuidToElement[supGuid];
if (hasOpposite)
{
if (!oppositeGuid.EndsWith("Client") && !oppositeGuid.EndsWith("Supplier"))
{
}
if (MainImport.getInstance().ReferenceGuidToReference.ContainsKey(oppositeGuid))
{
con = MainImport.getInstance().ReferenceGuidToReference[oppositeGuid];
refNode.getAttributeOrCreate(Main.GuidStringName).Value = "Client";
}
else
{
int supplierAggregation = 0;
int clientAggregation = 0;
if (containment)
{
if (oppositeGuid.EndsWith("Client"))
{
clientAggregation = 2;
}
else
{
supplierAggregation = 2;
}
}
con = createConnector(client, sqlRep.GetElementByID(supplier.ElementID), refGuid, Main.EAAssociationType, supplierAggregation, clientAggregation, hasOpposite);
refNode.getAttributeOrCreate(Main.GuidStringName).Value = "Supplier";
}
}
else
{
con = createConnector(sqlRep.GetElementByID(client.ElementID), sqlRep.GetElementByID(supplier.ElementID), refGuid, Main.EAAssociationType, 0, 0, hasOpposite);
refNode.getAttributeOrCreate(Main.GuidStringName).Value = "Supplier";
}
}
if (con != null)
{
if (!MainImport.getInstance().ReferenceGuidToReference.ContainsKey(refGuid))
{
MainImport.getInstance().ReferenceGuidToReference.Add(refGuid, con);
}
refGuid = refGuid.Replace("Client", "").Replace("Supplier", "");
if (!MainImport.getInstance().OldGuidToNewGuid.ContainsKey(refGuid))
{
MainImport.getInstance().OldGuidToNewGuid.Add(refGuid, con.ConnectorGUID);
}
if (!MainImport.getInstance().ReferenceGuidToReference.ContainsKey(con.ConnectorGUID))
{
MainImport.getInstance().ReferenceGuidToReference.Add(con.ConnectorGUID, con);
}
MocaNode referencesNodeSet = new MocaNode("references");
if (MainImport.getInstance().ReferenceGuidToClientTarget.ContainsKey(con.ConnectorGUID))
{
referencesNodeSet = MainImport.getInstance().ReferenceGuidToClientTarget[con.ConnectorGUID];
}
else
{
MainImport.getInstance().ReferenceGuidToClientTarget.Add(con.ConnectorGUID, referencesNodeSet);
}
referencesNodeSet.appendChildNode(refNode);
}
}
}
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);
}
