public void startImport(MocaNode importNode, List <String> mmsToImport, Boolean gui)
{
this.MocaTree = importNode;
hasGui = gui;
checkedMetamodelsToImport = mmsToImport;
try
{
doImport();
}
catch
{
int modelroot = 0;
if (hasGui)
{
MessageBox.Show("Import was not successfull. The Moca XMI file seems to be invalid");
}
else
{
Console.Out.WriteLine("ERROR:Import was not successfull. The Moca XMI file seems to be invalid#");
}
repository.RefreshModelView(modelroot);
}
finally
{
singleObject = null;
}
}
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;
}
}
/// <summary>
/// create Inheritance connectors
/// </summary>
public void setInheritances()
{
foreach (EA.Element element in MainImport.getInstance().ElementToBaseClassGuids.Keys)
{
if (MainImport.hasGui)
{
MainImport.getInstance().ImportWorker.ReportProgress(3, new ProgressObject(ProgressBarType.Current, "Create Inheritance", MainImport.getInstance().ElementToBaseClassGuids.Count));
}
String[] guids = MainImport.getInstance().ElementToBaseClassGuids[element].Split(" ".ToCharArray());
foreach (String baseClassGuid in guids)
{
if (baseClassGuid != "")
{
EA.Element baseClass = MainImport.getInstance().ElementGuidToElement[MainImport.getInstance().OldGuidToNewGuid[baseClassGuid]];
String result = repository.SQLQuery("select Connector_ID from t_connector where Connector_Type ='Generalization' AND Start_Object_ID = " + element.ElementID + " AND End_Object_ID = " + baseClass.ElementID);
if (EAUtil.getXMLNodeContentFromSQLQueryString(result, "Connector_ID")[0] == "")
{
EA.Connector inhCon = element.Connectors.AddNew("", "Generalization") as EA.Connector;
inhCon.SupplierID = baseClass.ElementID;
inhCon.Update();
}
}
}
}
}
public ObjectVariable importObjectVariable(SQLElement storyNode, MocaNode ovNode)
{
EA.Element ovElement = MainImport.getInstance().EcoreImport.getOrCreateElement(storyNode, ovNode, Main.EAObjectType);
MocaNode outgoingLinksNode = ovNode.getChildNodeWithName(ObjectVariable.OutgoingLinksNodeName);
if (outgoingLinksNode != null)
{
foreach (MocaNode outgoingLinkNode in outgoingLinksNode.Children)
{
MainImport.getInstance().ConnectorNodeToParent.Add(outgoingLinkNode, ovElement);
}
}
ObjectVariable ov = new ObjectVariable(sqlRep.GetElementByID(ovElement.ElementID), sqlRep);
ov.deserializeFromMocaTree(ovNode);
MainImport.getInstance().MocaTaggableElements.Add(ov);
MainImport.getInstance().ElementGuidToElement.Add(ovElement.ElementGUID, ovElement);
MainImport.getInstance().OldGuidToNewGuid.Add(ov.Guid, ovElement.ElementGUID);
MainImport.getInstance().ObjectToTypeGuid.Add(ovElement, ov.TypeGuid);
return(ov);
}
public void importTGGLinkVariable(MocaNode refNode, SQLElement parent)
{
LinkVariable lv = MainImport.getInstance().SdmImport.importLinkVariable(parent, refNode);
MainImport.getInstance().MocaTaggableElements.Remove(lv);
lv = new TGGLinkVariable(lv.LinkVariableEA, sqlRep);
lv.deserializeFromMocaTree(refNode);
MainImport.getInstance().MocaTaggableElements.Add(lv);
}
private void importCorrespondenceType(SQLPackage parentPackage, MocaNode eClassNode)
{
EClass eclass = MainImport.getInstance().EcoreImport.importEClass(parentPackage, eClassNode);
MainImport.getInstance().MocaTaggableElements.Remove(eclass);
eclass = new TGGCorrespondenceType(eclass.EaElement, sqlRep);
eclass.deserializeFromMocaTree(eClassNode);
MainImport.getInstance().MocaTaggableElements.Add(eclass);
}
private void importActivityNode(SQLElement sdmContainer, MocaNode activityNodeNode)
{
EA.Element activityNodeElement = null;
ActivityNode aNode = null;
if (activityNodeNode.getAttributeOrCreate("type").Value == "start")
{
activityNodeElement = MainImport.getInstance().EcoreImport.getOrCreateElement(sdmContainer, activityNodeNode, Main.EAStateNodeType, Main.EAStartNodeSubtype);
aNode = new StartNode(sqlRep, sqlRep.GetElementByID(activityNodeElement.ElementID));
}
else if (activityNodeNode.getAttributeOrCreate("type").Value == "stop")
{
activityNodeElement = MainImport.getInstance().EcoreImport.getOrCreateElement(sdmContainer, activityNodeNode, Main.EAStateNodeType, Main.EAStopNodeSubtype);
aNode = new StopNode(sqlRep, sqlRep.GetElementByID(activityNodeElement.ElementID));
}
else if (activityNodeNode.getAttributeOrCreate("type").Value == "statement")
{
activityNodeElement = MainImport.getInstance().EcoreImport.getOrCreateElement(sdmContainer, activityNodeNode, Main.EAActivityType);
aNode = new StatementNode(sqlRep, sqlRep.GetElementByID(activityNodeElement.ElementID));
}
else if (activityNodeNode.getAttributeOrCreate("type").Value == "story")
{
activityNodeElement = MainImport.getInstance().EcoreImport.getOrCreateElement(sdmContainer, activityNodeNode, Main.EAActivityType);
appendSdmDiagram(activityNodeElement.Name, activityNodeElement);
aNode = new StoryNode(sqlRep, sqlRep.GetElementByID(activityNodeElement.ElementID));
}
MocaNode outgoingEdgesNode = activityNodeNode.getChildNodeWithName(ActivityNode.OutgoingTransitionsNodeName);
if (outgoingEdgesNode != null)
{
foreach (MocaNode outgoingEdgeNode in outgoingEdgesNode.Children)
{
MainImport.getInstance().ConnectorNodeToParent.Add(outgoingEdgeNode, activityNodeElement);
}
}
MocaNode objectVariablesNode = activityNodeNode.getChildNodeWithName(StoryPattern.ObjectVariablesChildNodeName);
if (objectVariablesNode != null)
{
foreach (MocaNode ovNode in objectVariablesNode.Children)
{
importObjectVariable(sqlRep.GetElementByID(activityNodeElement.ElementID), ovNode);
}
}
aNode.deserializeFromMocaTree(activityNodeNode);
MainImport.getInstance().ElementGuidToElement.Add(activityNodeElement.ElementGUID, activityNodeElement);
MainImport.getInstance().OldGuidToNewGuid.Add(aNode.EaGuid, activityNodeElement.ElementGUID);
MainImport.getInstance().MocaTaggableElements.Add(aNode);
}
private static void appendSdmDiagram(String name, EA.Element parentElement)
{
if (parentElement.Diagrams.Count == 0)
{
EA.Diagram sdmDiagram = parentElement.Diagrams.AddNew(name, SDMModelingMain.SdmDiagramMetatype[0]) as EA.Diagram;
sdmDiagram.Update();
parentElement.Diagrams.Refresh();
MainImport.getInstance().DiagramsToBeFilled.Add(sdmDiagram);
}
}
private void importTGGCSP(SQLElement ruleElement, MocaNode cspInstanceNode)
{
EA.Element cspElement = MainImport.getInstance().EcoreImport.getOrCreateElement(ruleElement, cspInstanceNode, "Class");
CSPInstance cspIstance = new CSPInstance(sqlRep, sqlRep.GetElementByID(cspElement.ElementID));
cspIstance.deserializeFromMocaTree(cspInstanceNode);
MainImport.getInstance().MocaTaggableElements.Add(cspIstance);
MainImport.getInstance().ElementGuidToElement.Add(cspElement.ElementGUID, cspElement);
}
private void importEDatatype(SQLPackage parentPackage, MocaNode eDatatypeNode)
{
EA.Element edatatypeElement = getOrCreateElement(parentPackage, eDatatypeNode, "Class");
EDatatype edatatype = new EDatatype(sqlRep.GetElementByID(edatatypeElement.ElementID), sqlRep);
edatatype.deserializeFromMocaTree(eDatatypeNode);
MainImport.getInstance().ElementGuidToElement.Add(edatatypeElement.ElementGUID, edatatypeElement);
MainImport.getInstance().MocaTaggableElements.Add(edatatype);
MainImport.getInstance().OldGuidToNewGuid.Add(edatatype.Guid, edatatypeElement.ElementGUID);
}
// private static void appendTaggedValue()
#endregion
#region addDiagram methods
private static void appendDiagram(EA.Package parentPackage, String diagramMetaType, EA.Repository repository)
{
if (parentPackage.Diagrams.Count == 0)
{
EA.Diagram diag = parentPackage.Diagrams.AddNew(parentPackage.Name, "") as EA.Diagram;
diag.Update();
diag.StyleEx = "MDGDgm=" + "eMoflon Ecore Diagrams::Ecore Diagram" + ";";
diag.Update();
repository.Execute("UPDATE t_diagram SET Diagram_Type='" + diagramMetaType + "' WHERE Diagram_ID=" + diag.DiagramID);
MainImport.getInstance().DiagramsToBeFilled.Add(diag);
}
}
public static MainImport getInstance(SQLRepository sqlRep, BackgroundWorker importWorker)
{
if (singleObject == null)
{
singleObject = new MainImport(sqlRep);
}
if (importWorker != null)
{
singleObject.ImportWorker = importWorker;
}
return(singleObject);
}
public void importActivityEdge(SQLElement activityNodeElement, MocaNode activityEdgeNode)
{
String targetgGuid = MainImport.getInstance().OldGuidToNewGuid[activityEdgeNode.getAttributeOrCreate("targetGuid").Value];
EA.Element targetElement = MainImport.getInstance().ElementGuidToElement[targetgGuid];
EA.Connector activityEdgeConnector = MainImport.getInstance().EcoreImport.getOrCreateConnector(activityNodeElement, sqlRep.GetElementByID(targetElement.ElementID), activityEdgeNode.getAttributeOrCreate(Main.GuidStringName).Value, Main.EAControlFlowType);
ActivityEdge actEdge = new ActivityEdge(sqlRep, sqlRep.GetConnectorByID(activityEdgeConnector.ConnectorID));
actEdge.deserializeFromMocaTree(activityEdgeNode);
MainImport.getInstance().MocaTaggableElements.Add(actEdge);
}
private void importRulePackage(SQLPackage modelPackage, MocaNode packageNode)
{
EPackage ePackage = MainImport.getInstance().EcoreImport.importEPackage(packageNode, modelPackage);
MainImport.getInstance().MocaTaggableElements.Remove(ePackage);
ePackage = new TGGRulePackage(ePackage.EaPackage, sqlRep);
MainImport.getInstance().MocaTaggableElements.Add(ePackage);
foreach (MocaNode ruleNode in packageNode.getChildNodeWithName(TGGRulePackage.RulesChildNodeName).Children)
{
importRule(ePackage.EaPackage, ruleNode);
}
}
public EPackage importEPackage(MocaNode ePackageNode, SQLPackage parentPackage)
{
EA.Package modelPackage = getOrCreatePackage(parentPackage, ePackageNode);
EPackage ePkg = new EPackage(sqlRep.GetPackageByID(modelPackage.PackageID), sqlRep);
ePkg.deserializeFromMocaTree(ePackageNode);
MainImport.getInstance().MocaTaggableElements.Add(ePkg);
MainImport.getInstance().OldGuidToNewGuid.Add(ePkg.Guid, modelPackage.PackageGUID);
appendDiagram(modelPackage, "eMoflon Ecore Diagrams::Ecore Diagram", repository);// ECOREModelingMain.EcoreDiagramMetatype[0]);
importEPackageFeatures(ePackageNode, sqlRep.GetPackageByID(modelPackage.PackageID));
return(ePkg);
}
public void importSDMActivity(SQLElement parentEClass, SQLMethod owningOperation, MocaNode activityNode)
{
EA.Element activityElement = MainImport.getInstance().EcoreImport.getOrCreateElement(parentEClass, activityNode, Main.EAClassType);
appendSdmDiagram(owningOperation.Name, activityElement);
Activity sdmActivity = new Activity(sqlRep.GetElementByID(activityElement.ElementID), sqlRep);
sdmActivity.OwningOperation = new Modeling.ECOREModeling.ECOREExportWrapper.EOperation(sqlRep.GetMethodByID(owningOperation.MethodID), sqlRep);
MainImport.getInstance().MocaTaggableElements.Add(sdmActivity);
foreach (MocaNode activityNodeNode in activityNode.Children)
{
if (activityNodeNode.Name == "ActivityNode")
{
importActivityNode(sqlRep.GetElementByID(activityElement.ElementID), activityNodeNode);
}
}
}
internal void fillEcoreDiagram(EA.Diagram diagram)
{
EA.Collection elementCollection = null;
EA.Collection packageCollection = null;
if (diagram.PackageID != 0)
{
EA.Package pkg = (repository.GetPackageByID(diagram.PackageID) as EA.Package);
elementCollection = pkg.Elements;
packageCollection = pkg.Packages;
}
else if (diagram.ParentID != 0)
{
EA.Element ele = (repository.GetElementByID(diagram.ParentID) as EA.Element);
elementCollection = ele.Elements;
}
MainImport.fillDiagramFromCollections(diagram, elementCollection, packageCollection);
repository.GetProjectInterface().LayoutDiagramEx(diagram.DiagramGUID, EA.ConstLayoutStyles.lsDiagramDefault, 4, 20, 20, true);
}
public LinkVariable importLinkVariable(SQLElement ovElement, MocaNode lvNode)
{
String oldTargetGuid = lvNode.getAttributeOrCreate("targetGuid").Value;
String newTargetGuid = MainImport.getInstance().OldGuidToNewGuid[oldTargetGuid];
EA.Element targetElement = MainImport.getInstance().ElementGuidToElement[newTargetGuid];
EA.Connector newLinkConnector = MainImport.getInstance().EcoreImport.getOrCreateConnector(ovElement, sqlRep.GetElementByID(targetElement.ElementID), lvNode.getAttributeOrCreate(Main.GuidStringName).Value, Main.EAAssociationType);
LinkVariable lv = new LinkVariable(sqlRep.GetConnectorByID(newLinkConnector.ConnectorID), sqlRep);
lv.deserializeFromMocaTree(lvNode);
if (lv.linkDialogueEntry.clientRoleName != "" && lv.linkDialogueEntry.supplierRoleName != "")
{
lv.linkDialogueEntry.direction = LinkDialogueEntryDirection.BI;
}
MainImport.getInstance().MocaTaggableElements.Add(lv);
return(lv);
}
private void importEEnum(SQLPackage parentPackage, MocaNode eEnumNode)
{
EA.Element eenumElement = getOrCreateElement(parentPackage, eEnumNode, "Enumeration");
foreach (MocaNode literalNode in eEnumNode.getChildNodeWithName("literals").Children)
{
String literalName = literalNode.getAttributeOrCreate("name").Value;
if (literalName != "" && !literalExist(eenumElement, literalName))
{
EA.Attribute literalAtt = eenumElement.Attributes.AddNew(literalName, "") as EA.Attribute;
literalAtt.Update();
}
}
eenumElement.Attributes.Refresh();
EEnum eenum = new EEnum(sqlRep.GetElementByID(eenumElement.ElementID), sqlRep);
eenum.deserializeFromMocaTree(eEnumNode);
MainImport.getInstance().ElementGuidToElement.Add(eenumElement.ElementGUID, eenumElement);
MainImport.getInstance().MocaTaggableElements.Add(eenum);
MainImport.getInstance().OldGuidToNewGuid.Add(eenum.Guid, eenumElement.ElementGUID);
}
public void importTGGPackageModel(MocaNode tggPackageNode)
{
EA.Package rootPackage = MainImport.getInstance().EcoreImport.findOrCreateRoot(tggPackageNode);
EA.Package modelPackage = MainImport.getInstance().EcoreImport.getOrCreatePackage(sqlRep.GetPackageByID(rootPackage.PackageID), tggPackageNode);
TGG tggPkg = new TGG(sqlRep, sqlRep.GetPackageByID(modelPackage.PackageID));
tggPkg.deserializeFromMocaTree(tggPackageNode);
MainImport.getInstance().MocaTaggableElements.Add(tggPkg);
MainImport.getInstance().OldGuidToNewGuid.Add(tggPkg.Guid, modelPackage.PackageGUID);
MainImport.getInstance().importedPackages.Add(modelPackage);
if (modelPackage.Diagrams.Count == 0)
{
EA.Diagram diag = modelPackage.Diagrams.AddNew(modelPackage.Name, TGGModelingMain.TggSchemaDiagramMetatype[0]) as EA.Diagram;
diag.Update();
MainImport.getInstance().DiagramsToBeFilled.Add(diag);
}
MainImport.getInstance().EcoreImport.importEPackageFeatures(tggPackageNode, sqlRep.GetPackageByID(modelPackage.PackageID));
importTGGFeatures(tggPackageNode, sqlRep.GetPackageByID(modelPackage.PackageID));
}
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);
}
}
}
private void importRule(SQLPackage modelPackage, MocaNode ruleNode)
{
EA.Element ruleElement = MainImport.getInstance().EcoreImport.getOrCreateElement(modelPackage, ruleNode, Main.EAClassType);
if (ruleElement.Diagrams.Count == 0)
{
EA.Diagram ruleDiagram = ruleElement.Diagrams.AddNew(ruleElement.Name, TGGModelingMain.TggRuleDiagramMetatype[0]) as EA.Diagram;
ruleDiagram.Update();
MainImport.getInstance().DiagramsToBeFilled.Add(ruleDiagram);
}
EA.Method mainMethod = MainImport.getInstance().EcoreImport.getOrCreateMethod(sqlRep.GetElementByID(ruleElement.ElementID), ruleNode.getAttributeOrCreate("mainMethodGuid").Value, ruleElement.Name, "");
MocaNode parametersNode = ruleNode.getChildNodeWithName(EOperation.ParametersChildNodeName);
if (parametersNode != null)
{
foreach (MocaNode paramNode in parametersNode.Children)
{
EA.Parameter parameter = MainImport.getInstance().EcoreImport.getOrCreateParameter(mainMethod, paramNode);
MainImport.getInstance().OldGuidToNewGuid.Add(paramNode.getAttributeOrCreate(Main.GuidStringName).Value, parameter.ParameterGUID);
}
}
EClass eClass = MainImport.getInstance().EcoreImport.importEClassFeatures(ruleNode, sqlRep.GetElementByID(ruleElement.ElementID));
MainImport.getInstance().MocaTaggableElements.Remove(eClass);
TGGRule rule = new TGGRule(sqlRep, sqlRep.GetElementByID(ruleElement.ElementID));
rule.deserializeFromMocaTree(ruleNode);
MainImport.getInstance().MocaTaggableElements.Add(rule);
foreach (MocaNode ovNode in ruleNode.getChildNodeWithName(StoryPattern.ObjectVariablesChildNodeName).Children)
{
if (ovNode.Name == TGGModelingMain.TggObjectVariableStereotype)
{
ObjectVariable ov = MainImport.getInstance().SdmImport.importObjectVariable(sqlRep.GetElementByID(ruleElement.ElementID), ovNode);
MainImport.getInstance().MocaTaggableElements.Remove(ov);
ov = new TGGObjectVariable(ov.sqlElement, sqlRep);
ov.deserializeFromMocaTree(ovNode);
MainImport.getInstance().MocaTaggableElements.Add(ov);
}
else if (ovNode.Name == TGGCorrespondence.CorrespondenceNodeName)
{
ObjectVariable ov = MainImport.getInstance().SdmImport.importObjectVariable(sqlRep.GetElementByID(ruleElement.ElementID), ovNode);
MainImport.getInstance().MocaTaggableElements.Remove(ov);
ov = new TGGCorrespondence(ov.sqlElement, sqlRep);
ov.deserializeFromMocaTree(ovNode);
MainImport.getInstance().MocaTaggableElements.Add(ov);
}
}
MocaNode cspsNode = ruleNode.getChildNodeWithName(TGGRule.CspsChildNodeName);
if (cspsNode != null)
{
foreach (MocaNode cspInstanceNode in cspsNode.Children)
{
importTGGCSP(sqlRep.GetElementByID(ruleElement.ElementID), cspInstanceNode);
}
}
else
{
if (ruleNode.getAttributeOrCreate(TGGRule.CspSpecAttributeName).Value != "")
{
EA.Element constraintElement = ruleElement.Elements.AddNew("", Main.EAClassType) as EA.Element;
constraintElement.Stereotype = TGGModelingMain.CSPConstraintStereotype;
constraintElement.Notes = ruleNode.getAttributeOrCreate(TGGRule.CspSpecAttributeName).Value;
constraintElement.Update();
CSPInstance cspInstance = new CSPInstance(sqlRep, sqlRep.GetElementByID(constraintElement.ElementID));
cspInstance.CspStringValueFromImport = ruleNode.getAttributeOrCreate(TGGRule.CspSpecAttributeName).Value;
MainImport.getInstance().MocaTaggableElements.Add(cspInstance);
}
}
}
public EClass importEClassFeatures(MocaNode eClassNode, SQLElement eclassElem)
{
MocaNode operationsNode = eClassNode.getChildNodeWithName(EClass.OperationsChildNodeName);
MocaNode attributesNode = eClassNode.getChildNodeWithName(EClass.AttributesChildNodeName);
MocaNode refsNode = eClassNode.getChildNodeWithName(EClass.ReferencesChildNodeName);
foreach (MocaNode eOpNode in operationsNode.Children)
{
EA.Method eaMethod = getOrCreateMethod(eclassElem, eOpNode);
foreach (MocaNode eParamNode in eOpNode.getChildNodeWithName(EOperation.ParametersChildNodeName).Children)
{
if (eParamNode.Name == "EParameter")
{
EA.Parameter eaParam = getOrCreateParameter(eaMethod, eParamNode);
}
}
eaMethod.Parameters.Refresh();
MocaNode sdmActivityNode = eOpNode.getChildNodeWithName("Activity");
if (sdmActivityNode != null)
{
MainImport.getInstance().SdmImport.importSDMActivity(eclassElem, sqlRep.GetMethodByID(eaMethod.MethodID), sdmActivityNode);
}
}
foreach (MocaNode eAttrNode in attributesNode.Children)
{
EA.Attribute eAttribute = getOrCreateAttribute(eclassElem, eAttrNode);;
eAttribute.Update();
}
if (refsNode.Children.Count != 0)
{
MainImport.getInstance().ConnectorNodeToParent.Add(refsNode, eclassElem.getRealElement());
}
eclassElem.Attributes.Refresh();
eclassElem.Methods.Refresh();
EClass eclass = new EClass(sqlRep.GetElementByID(eclassElem.ElementID), sqlRep);
eclass.deserializeFromMocaTree(eClassNode);
foreach (EAttribute eattr in eclass.EAttributes)
{
if (eattr.typeGuid != "")
{
MainImport.getInstance().ObjectToTypeGuid.Add(eattr.EaAttribute.getRealAttribute(), eattr.typeGuid);
}
MainImport.getInstance().OldGuidToNewGuid.Add(eattr.guid, eattr.EaAttribute.AttributeGUID);
}
foreach (EOperation eOp in eclass.EOperations)
{
if (eOp.typeGuid != "")
{
MainImport.getInstance().ObjectToTypeGuid.Add(eOp.EaMethod.getRealMethod(), eOp.typeGuid);
}
MainImport.getInstance().OldGuidToNewGuid.Add(eOp.guid, eOp.EaMethod.MethodGUID);
foreach (EParameter eParam in eOp.EParameters)
{
if (eParam.typeGuid != "")
{
MainImport.getInstance().ObjectToTypeGuid.Add(eParam.EaParameter.getRealParameter(), eParam.typeGuid);
}
MainImport.getInstance().OldGuidToNewGuid.Add(eParam.Guid, eParam.EaParameter.ParameterGUID);
}
}
if (eClassNode.getAttributeOrCreate("baseClasses").Value != "")
{
MainImport.getInstance().ElementToBaseClassGuids.Add(eclassElem.getRealElement(), eClassNode.getAttributeOrCreate("baseClasses").Value);
}
MainImport.getInstance().ElementGuidToElement.Add(eclassElem.ElementGUID, eclassElem.getRealElement());
MainImport.getInstance().MocaTaggableElements.Add(eclass);
MainImport.getInstance().OldGuidToNewGuid.Add(eclass.Guid, eclassElem.ElementGUID);
return(eclass);
}