private void cleanUpEA(EA.ConnectorEnd eaSupEnd, EA.ConnectorEnd eaCliEnd, EReference eRef)
{
eaSupEnd.Role = eRef.SupplierEnd.Name;
eaSupEnd.Update();
eaCliEnd.Role = eRef.ClientEnd.Name;
eaCliEnd.Update();
// repair Suppliers End
if (eaSupEnd.Role == null || eaSupEnd.Role == "")
{
eaSupEnd.Cardinality = "";
}
else
{
eaSupEnd.Cardinality = eRef.SupplierEnd.lowerBound.Replace("-1", "*") + ".." + eRef.SupplierEnd.upperBound.Replace("-1", "*");
}
eaSupEnd.Update();
// repair Cliend End
if (eaCliEnd.Role == null || eaCliEnd.Role == "")
{
eaCliEnd.Cardinality = "";
}
else
{
eaCliEnd.Cardinality = eRef.ClientEnd.lowerBound.Replace("-1", "*") + ".." + eRef.ClientEnd.upperBound.Replace("-1", "*");
}
eaCliEnd.Update();
}
public void processEReference(SQLConnector eaReference, String clientOrSupplier)
{
SQLConnectorTag mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaReference, Main.MoflonExportTreeTaggedValueName);
EReference eReference = null;
if (mocaTreeTag == null)
{
eReference = new EReference(eaReference, repository);
eReference.saveTreeToEATaggedValue(true);
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);
}
Export.computeAndAddToDependencies(repository, eTypeElement);
this.currentNode.appendChildNode(referenceEndNode);
}
public void EA_OnNotifyContextItemModified(EA.Repository Repository, String GUID, EA.ObjectType ot)
{
SQLRepository sqlRepository = new SQLRepository(Repository, false);
if (ot == EA.ObjectType.otPackage)
{
EA.Package eaPackage = Repository.GetPackageByGuid(GUID);
if (eaPackage.Element.Stereotype.ToLower() == ECOREModelingMain.EPackageStereotype.ToLower())
{
EPackage ePackage = new EPackage(sqlRepository.GetPackageByID(eaPackage.PackageID), sqlRepository);
Main.addToTreeQueue(GUID, ePackage);
}
// track changes for metamodelevolution
savePackageChangesToEATaggedValue(sqlRepository, GUID);
}
if (ot == EA.ObjectType.otElement)
{
SQLElement eaElement = sqlRepository.GetElementByGuid(GUID);
if (eaElement.Stereotype.ToLower() == EClassStereotype.ToLower() && eaElement.Type == Main.EAClassType)
{
EClass eClass = new EClass(eaElement, sqlRepository);
eClass.saveTreeToEATaggedValue(false);
// track changes for metamodelevolution
saveElementChangesToEATaggedValue(eaElement, GUID, sqlRepository);
}
else if (eaElement.Stereotype.ToLower() == EDatatypeStereotype.ToLower())
{
EDatatype eDataType = new EDatatype(eaElement, sqlRepository);
eDataType.saveTreeToEATaggedValue(false);
}
else if (eaElement.Stereotype.ToLower() == EEnumStereotype.ToLower())
{
EEnum eEnum = new EEnum(eaElement, sqlRepository);
eEnum.saveTreeToEATaggedValue(false);
}
}
if (ot == EA.ObjectType.otConnector)
{
SQLConnector eaConnector = sqlRepository.GetConnectorByGuid(GUID);
if (eaConnector.Type == EReferenceConnectorType && (eaConnector.Stereotype == "" || eaConnector.Stereotype.ToLower() == "ereference"))
{
EReference clientReference = new EReference(eaConnector, sqlRepository);
clientReference.saveTreeToEATaggedValue(false);
}
else if (eaConnector.Type == InheritanceConnectorType)
{
SQLElement connectorSource = sqlRepository.GetElementByID(eaConnector.ClientID);
if (connectorSource.Stereotype == EClassStereotype)
{
EClass eClass = new EClass(connectorSource, sqlRepository);
eClass.saveTreeToEATaggedValue(false);
}
}
}
}
public override void doRuleQuickFix(SQLConnector eaConnector, SQLWrapperClasses.SQLRepository repository, int i, string errorMessage)
{
if (i == 0)
{
EReference eref = new EReference(eaConnector, repository);
eref.saveTreeToEATaggedValue(true);
}
}
public NotificationChain basicSetEOpposite(EReference newobj, NotificationChain msgs)
{
var oldobj = _eOpposite;
_eOpposite = newobj;
if (eNotificationRequired())
{
var notification = new ENotificationImpl(this, NotificationImpl.SET, EcorePackageImpl.EREFERENCE_EOPPOSITE, oldobj, newobj);
if (msgs == null)
{
msgs = notification;
}
else
{
msgs.add(notification);
}
}
return(msgs);
}
protected EReference initEReference
(EReference r,
EGenericType type,
EReference otherEnd,
String name,
String defaultValue,
int lowerBound,
int upperBound,
Type containerClass,
bool isTransient,
bool isVolatile,
bool isChangeable,
bool isContainment,
bool isResolveProxies,
bool isUnsettable,
bool isUnique,
bool isDerived,
bool isOrdered)
{
initEStructuralFeature
(r,
type,
name,
defaultValue,
lowerBound,
upperBound,
containerClass,
isTransient,
isVolatile,
isChangeable,
isUnsettable,
isUnique,
isDerived,
isOrdered);
r.containment = isContainment;
if (otherEnd != null)
{
r.eOpposite = otherEnd;
}
r.resolveProxies = isResolveProxies;
return(r);
}
public bool validate_EveryBidirectionalReferenceIsPaired(EObject eObject, DiagnosticChain diagnostics, Dictionary <object, object> context)
{
bool result = true;
foreach (EReference eReference in eObject.eClass().eAllReferences)
{
if (eReference.resolveProxies)
{
EReference eOpposite = eReference.eOpposite;
if (eOpposite != null)
{
result &= validate_BidirectionalReferenceIsPaired(eObject, eReference, eOpposite, diagnostics, context);
if (!result && diagnostics == null)
{
return(false);
}
}
}
}
return(result);
}
public override void doRuleQuickFix(SQLConnector eaConnector2, SQLRepository repository, int i, String errorMessage)
{
EA.Connector eaConnector = eaConnector2.getRealConnector();
if (i == 0)
{
if (eaConnector.ClientEnd.Role != "" && eaConnector.SupplierEnd.Role != "")
{
eaConnector.Direction = "Bi-Directional";
}
else if (eaConnector.ClientEnd.Role != "" && eaConnector.ClientEnd.Navigable != "Navigable")
{
eaConnector.ClientEnd.Navigable = "Navigable";
eaConnector.ClientEnd.IsNavigable = true;
eaConnector.ClientEnd.Update();
//eaConnector.Direction = Main.EATargetSourceDirection;
//eaConnector.Update();
}
else if (eaConnector.SupplierEnd.Role != "" && eaConnector.SupplierEnd.Navigable != "Navigable")
{
eaConnector.SupplierEnd.Navigable = "Navigable";
eaConnector.SupplierEnd.IsNavigable = true;
eaConnector.SupplierEnd.Update();
//eaConnector.Direction = "Source -> Destination";
//eaConnector.Update();
}
eaConnector.Update();
EA.Diagram currentDiagram = repository.GetCurrentDiagram();
if (currentDiagram != null)
{
repository.ReloadDiagram(currentDiagram.DiagramID);
}
EReference eRef = new EReference(repository.GetConnectorByID(eaConnector.ConnectorID), repository);
eRef.saveTreeToEATaggedValue(false);
}
}
public bool validate_EveryKeyUnique(EObject eObject, DiagnosticChain diagnostics, Dictionary <object, object> context)
{
bool result = true;
EClass eClass = eObject.eClass();
for (int i = 0, size = eClass.getFeatureCount(); i < size; ++i)
{
EStructuralFeature eStructuralFeature = eClass.getEStructuralFeature(i);
if (eStructuralFeature is EReference)
{
EReference eReference = (EReference)eStructuralFeature;
if (eReference.many && !eReference.eKeys.isEmpty())
{
result &= validate_KeyUnique(eObject, eReference, diagnostics, context);
if (!result && diagnostics == null)
{
return(false);
}
}
}
}
return(result);
}
public override List <String> doRule(SQLConnector eaConnector, SQLWrapperClasses.SQLRepository repository)
{
List <String> results = new List <string>();
SQLElement clientClass = repository.GetElementByID(eaConnector.ClientID);
if (clientClass.Stereotype == ECOREModelingMain.EClassStereotype && eaConnector.Type == ECOREModelingMain.EReferenceConnectorType)
{
SQLConnector con = eaConnector;
SQLElement supplierClass = repository.GetElementByID(con.SupplierID);
EReference eReference = new EReference(con, repository);
eReference.loadTreeFromTaggedValue();
if ((con.ClientEnd.Navigable == "Navigable" && eReference.ClientEnd.typeGUID != clientClass.ElementGUID) ||
(con.SupplierEnd.Navigable == "Navigable" && eReference.SupplierEnd.typeGUID != supplierClass.ElementGUID))
{
results.Add("Moca fragment of EReference is invalid and must be refreshed");
}
}
return(results);
}
public bool validateEReference(EReference obj, DiagnosticChain diagnostics, Dictionary <object, object> context)
{
if (!validate_NoCircularContainment(obj, diagnostics, context))
{
return(false);
}
bool result = validate_EveryMultiplicityConforms(obj, diagnostics, context);
if (result || diagnostics != null)
{
result &= validate_EveryDataValueConforms(obj, diagnostics, context);
}
if (result || diagnostics != null)
{
result &= validate_EveryReferenceIsContained(obj, diagnostics, context);
}
if (result || diagnostics != null)
{
result &= validate_EveryBidirectionalReferenceIsPaired(obj, diagnostics, context);
}
//if (result || diagnostics != null) result &= validate_EveryProxyResolves(obj, diagnostics, context);
if (result || diagnostics != null)
{
result &= validate_UniqueID(obj, diagnostics, context);
}
if (result || diagnostics != null)
{
result &= validate_EveryKeyUnique(obj, diagnostics, context);
}
if (result || diagnostics != null)
{
result &= validate_EveryMapEntryUnique(obj, diagnostics, context);
}
return(result);
}
private EA.Element createNewCorrespondenceLink(EA.Package tggOutermostePackage, out EA.Connector connectorToSource, out EA.Connector connectorToTarget)
{
EA.Element tggLink = tggOutermostePackage.Elements.AddNew(textBoxLinkName.Text, Main.EAClassType) as EA.Element;
tggLink.StereotypeEx = TGGModelingMain.TggCorrespondenceTypeStereotype;
tggLink.Update();
TGGCorrespondenceType correspondenceType = new TGGCorrespondenceType(sqlRepository.GetElementByID(tggLink.ElementID), sqlRepository);
correspondenceType.saveTreeToEATaggedValue(false);
connectorToSource = tggLink.Connectors.AddNew("", ECOREModelingMain.EReferenceConnectorType) as EA.Connector;
connectorToSource.SupplierID = clientClassifier.ElementID;
connectorToSource.Direction = Main.EASourceTargetDirection;
connectorToSource.SupplierEnd.Role = "source";
connectorToSource.SupplierEnd.Navigable = "Navigable";
connectorToSource.SupplierEnd.Cardinality = "1";
connectorToSource.SupplierEnd.IsNavigable = true;
connectorToSource.Update();
EReference refToSource = new EReference(sqlRepository.GetConnectorByID(connectorToSource.ConnectorID), sqlRepository);
refToSource.saveTreeToEATaggedValue(true);
tggLink.Connectors.Refresh();
connectorToTarget = tggLink.Connectors.AddNew("", ECOREModelingMain.EReferenceConnectorType) as EA.Connector;
connectorToTarget.SupplierID = supplierClassifier.ElementID;
connectorToTarget.Direction = Main.EASourceTargetDirection;
connectorToTarget.SupplierEnd.Role = "target";
connectorToTarget.SupplierEnd.Cardinality = "1";
connectorToTarget.SupplierEnd.Navigable = "Navigable";
connectorToTarget.SupplierEnd.IsNavigable = true;
connectorToTarget.Update();
EReference refToTarget = new EReference(sqlRepository.GetConnectorByID(connectorToTarget.ConnectorID), sqlRepository);
refToTarget.saveTreeToEATaggedValue(true);
selectedCorrespondenceLinkId = tggLink.ElementID;
EA.Diagram curDiagram = null;
EA.DiagramObject sourceDiagObj = null;
EA.DiagramObject targetDiagObj = null;
foreach (EA.Diagram diag in tggOutermostePackage.Diagrams)
{
foreach (EA.DiagramObject diagObj in diag.DiagramObjects)
{
if (diagObj.ElementID == clientClassifier.ElementID)
{
sourceDiagObj = diagObj;
}
else if (diagObj.ElementID == supplierClassifier.ElementID)
{
targetDiagObj = diagObj;
}
if (sourceDiagObj != null && targetDiagObj != null)
{
curDiagram = diag;
}
}
}
if (curDiagram != null)
{
sqlRepository.SaveDiagram(curDiagram.DiagramID);
int sourceLeft = (sourceDiagObj == null) ? 0 : sourceDiagObj.left;
int sourceRight = (sourceDiagObj == null) ? 0 : sourceDiagObj.right;
int sourceBottom = (sourceDiagObj == null) ? 0 : sourceDiagObj.bottom;
int sourceTop = (sourceDiagObj == null) ? 0 : sourceDiagObj.top;
int targetLeft = (targetDiagObj == null) ? 0 : targetDiagObj.left;
int targetRight = (targetDiagObj == null) ? 0 : targetDiagObj.right;
int targetBottom = (targetDiagObj == null) ? 0 : targetDiagObj.bottom;
int targetTop = (targetDiagObj == null) ? 0 : targetDiagObj.top;
EA.DiagramObject tggLinkDiagObj = curDiagram.DiagramObjects.AddNew("", "") as EA.DiagramObject;
tggLinkDiagObj.ElementID = tggLink.ElementID;
tggLinkDiagObj.Update();
tggLinkDiagObj.left = (sourceLeft + targetLeft) / 2;
tggLinkDiagObj.right = (sourceRight + targetRight) / 2;
tggLinkDiagObj.bottom = (sourceBottom + targetBottom) / 2;
tggLinkDiagObj.top = (sourceTop + targetTop) / 2;
tggLinkDiagObj.Update();
curDiagram.DiagramObjects.Refresh();
sqlRepository.ReloadDiagram(curDiagram.DiagramID);
tggOutermostePackage.Elements.Refresh();
}
return(tggLink);
}
private static void onNotifyEReferenceModified(SQLRepository sqlRepository, EA.Connector con)
{
EReference eRef = new EReference(sqlRepository.GetConnectorByID(con.ConnectorID), sqlRepository);
eRef.saveTreeToEATaggedValue(true);
}
public virtual T caseEReference(EReference theEObject)
{
return(default(T));
}
/// <summary>
/// Checks if the new created Element is an SDM related Element.
/// Opens the custom User Dialogues or sets default values if it is necessary.
/// </summary>
/// <param name="sqlRep"></param>
/// <param name="Info"></param>
/// <returns>if newElement is still valid</returns>
public bool EA_OnPostNewElement(SQLRepository sqlRep, EA.Element newElement, EA.Diagram currentDiagram)
{
if (SdmDiagramMetatype.Contains(currentDiagram.MetaType))
{
sqlRep.SuppressEADialogs = true;
if (newElement.Stereotype == SDMModelingMain.ObjectVariableQuickCreateStereotype)
{
newElement.Stereotype = SDMModelingMain.ObjectVariableStereotype;
ObjectVariable ov = new ObjectVariable(sqlRep.GetElementByID(newElement.ElementID), sqlRep);
OvDialog objectVariableDialogue = new OvDialog(sqlRep, ov);
List <SQLElement> validEClassesTemp = new List <SQLElement>();
List <EClass> validEClasses = new List <EClass>();
SQLElement sourceObjectVariable = sqlRep.GetElementByGuid(Main.lastContextItemGUID);
SQLElement classifier = sqlRep.GetElementByID(sourceObjectVariable.ClassifierID);
foreach (SQLElement baseclass in EAUtil.getBaseClasses(classifier))
{
foreach (SQLConnector connector in baseclass.Connectors)
{
if (connector.Type == ECOREModelingMain.EReferenceConnectorType)
{
EReference eRef = new EReference(connector, sqlRep);
eRef.loadTreeFromTaggedValue();
SQLElement otherEnd = null;
if (connector.ClientID == baseclass.ElementID && eRef.SupplierEnd.Navigable)
{
otherEnd = sqlRep.GetElementByID(connector.SupplierID);
}
else if (connector.SupplierID == baseclass.ElementID && eRef.ClientEnd.Navigable)
{
otherEnd = sqlRep.GetElementByID(connector.ClientID);
}
if (otherEnd != null && otherEnd.Stereotype == ECOREModelingMain.EClassStereotype)
{
validEClassesTemp.Add(otherEnd);
}
}
}
}
objectVariableDialogue.ovPropertiesControl.comboTypes.clearClassifiers();
foreach (SQLElement tempClassifier in validEClassesTemp)
{
objectVariableDialogue.ovPropertiesControl.comboTypes.addClassifier(new EClass(tempClassifier, sqlRep));
}
objectVariableDialogue.ovPropertiesControl.comboTypes.printClassifiers();
objectVariableDialogue.ShowDialog();
}
else if (newElement.Stereotype == SDMModelingMain.ObjectVariableStereotype || (newElement.Type == Main.EAObjectType && newElement.Stereotype == ""))
{
Boolean dragAndDropUsed = newElement.ClassifierID != 0;
if (dragAndDropUsed && !classifierIsValid(sqlRep, newElement))
{
Main.addToDeleteGUIDQueue(newElement.ElementGUID);
return(false);
}
EA.DiagramObject diagObj = EAEcoreAddin.Util.EAUtil.findDiagramObject(sqlRep, newElement, currentDiagram);
foreach (EA.DiagramObject diagObjs in currentDiagram.DiagramObjects)
{
if (diagObj.left > (diagObjs.left - 45) && diagObj.right < (diagObjs.right + 45) && diagObj.top < (diagObjs.top + 30) && diagObj.bottom > (diagObjs.bottom - 30))
{
if (newElement.ElementID != diagObjs.ElementID)
{
EA.Element realElement = sqlRep.GetOriginalRepository().GetElementByID(newElement.ElementID);
realElement.ParentID = diagObjs.ElementID;
realElement.Update();
break;
}
}
}
//recompute newElement because of drag and drop changes to the element
if (dragAndDropUsed)
{
newElement = sqlRep.GetOriginalRepository().GetElementByID(newElement.ElementID);
}
newElement.Stereotype = SDMModelingMain.ObjectVariableStereotype;
ObjectVariable ov = new ObjectVariable(sqlRep.GetElementByID(newElement.ElementID), sqlRep);
OvDialog objectVariableDialogue = new OvDialog(sqlRep, ov);
objectVariableDialogue.ShowDialog();
}
else if (newElement.Stereotype == SDMModelingMain.StoryNodeStereotype)
{
//save initial data for storyNode
EAEcoreAddin.Util.EAUtil.setTaggedValue(sqlRep, newElement, Main.MoflonExtractedStoryPatternTaggedValueName, "false");
StoryNode storyNode = new StoryNode(sqlRep, sqlRep.GetElementByID(newElement.ElementID));
storyNode.ForEach = false;
storyNode.saveTreeToEATaggedValue(true);
}
else if (newElement.Stereotype == SDMModelingMain.StopNodeStereotype)
{
//save initial data for stopNode
StopNode stopNode = new StopNode(sqlRep, sqlRep.GetElementByID(newElement.ElementID));
stopNode.saveTreeToEATaggedValue(true);
}
else if (newElement.Stereotype == SDMModelingMain.StartNodeStereotype)
{
//save initial data for startNode
StartNode startNode = new StartNode(sqlRep, sqlRep.GetElementByID(newElement.ElementID));
startNode.saveTreeToEATaggedValue(false);
}
else if (newElement.Stereotype == SDMModelingMain.CSPInstanceStereotype)
{
EA.DiagramObject instanceObject = EAUtil.findDiagramObject(sqlRep, newElement, sqlRep.GetCurrentDiagram());
instanceObject.right = instanceObject.left + 225;
instanceObject.bottom = instanceObject.top - 125;
instanceObject.Update();
SDMCSPDialog sdmCspDialog = new SDMCSPDialog(sqlRep.GetElementByID(newElement.ElementID), sqlRep);
sdmCspDialog.ShowDialog();
}
}
return(true);
}
private void saveRecurr(EObject eobject, EReference relation)
{
if (eobject == null)
{
return;
}
var xmlAttributes = new Dictionary <string, string>();
//xsi:type="ecore:EAttribute"
var eclass = eobject.eClass();
var epackag = eclass.ePackage;
if (epackag == null)
{
return;
}
var prefix = epackag.nsPrefix;
xmlAttributes["xsi:type"] = eobject.eClass().ePackage.nsPrefix + ":" + eobject.eClass().name;
foreach (EStructuralFeature feature in eobject.eClass().eAllStructuralFeatures)
{
if (feature is EReference)
{
var erference = feature as EReference;
if (erference.many)
{
//TODO
}
else
{
var value = eobject.eGet(erference) as EObject;
if (value != null)
{
xmlAttributes[erference.name] = getFragment(value);
}
}
if (erference.containment)
{
var child = eobject.eGet(erference);
if (child != null)
{
if (erference.many)
{
var list = (IList)child;
var list2 = list.Cast <EObject>();
foreach (EObject c in list)
{
saveRecurr(c, erference);
}
}
else
{
saveRecurr(child as EObject, erference);//TODO is casting safe here?
}
}
}
}
else if (feature is EAttribute)
{
var eattribute = feature as EAttribute;
if (!eattribute.transient && !eattribute.derived && eattribute.defaultValue != eobject.eGet(eattribute))
{
//TODO many
xmlAttributes[eattribute.name] = eobject.eGet(eattribute).ToString();
}
}
}
if (relation != null)
{
var sb = new StringBuilder();
sb.Append($"<{relation.name}");
foreach (String key in xmlAttributes.Keys)
{
sb.Append($"{key}=\"{xmlAttributes[key]}\"");
}
sb.Append($">");
//TODO childs
sb.Append($"</{relation.name}>");
Console.WriteLine(sb.ToString());
}
}
public bool validate_BidirectionalReferenceIsPaired(EObject eObject, EReference eReference, EReference eOpposite, DiagnosticChain diagnostics, Dictionary <object, object> context)
{
bool result = true;
Object value = eObject.eGet(eReference);
if (eReference.many)
{
List <EObject> values = (List <EObject>)value;
if (eOpposite.many)
{
foreach (EObject oppositeEObject in values)
{
List <EObject> oppositeValues = (List <EObject>)oppositeEObject.eGet(eOpposite);
if (!oppositeValues.Contains(eObject))
{
result = false;
if (diagnostics != null)
{
// TODO
diagnostics.add
(createDiagnostic
(BasicDiagnostic.ERROR,
DIAGNOSTIC_SOURCE,
EOBJECT__EVERY_BIDIRECTIONAL_REFERENCE_IS_PAIRED,
"_UI_UnpairedBidirectionalReference_diagnostic",
new Object[]
{
getFeatureLabel(eReference, context),
getObjectLabel(eObject, context),
getFeatureLabel(eOpposite, context),
getObjectLabel(oppositeEObject, context),
},
new Object[] { eObject, eReference, oppositeEObject, eOpposite },
context));
}
else
{
break;
}
}
}
}
else
{
foreach (EObject oppositeEObject in values)
{
if (oppositeEObject.eGet(eOpposite) != eObject)
{
result = false;
if (diagnostics != null)
{
// TODO
diagnostics.add
(createDiagnostic
(BasicDiagnostic.ERROR,
DIAGNOSTIC_SOURCE,
EOBJECT__EVERY_BIDIRECTIONAL_REFERENCE_IS_PAIRED,
"_UI_UnpairedBidirectionalReference_diagnostic",
new Object[]
{
getFeatureLabel(eReference, context),
getObjectLabel(eObject, context),
getFeatureLabel(eOpposite, context),
getObjectLabel(oppositeEObject, context),
},
new Object[] { eObject, eReference, oppositeEObject, eOpposite },
context));
}
else
{
break;
}
}
}
}
}
else
{
EObject oppositeEObject = (EObject)value;
if (oppositeEObject != null)
{
if (eOpposite.many)
{
List <EObject> oppositeValues = (List <EObject>)oppositeEObject.eGet(eOpposite);
if (!oppositeValues.Contains(eObject))
{
result = false;
if (diagnostics != null)
{
// TODO
diagnostics.add
(createDiagnostic
(BasicDiagnostic.ERROR,
DIAGNOSTIC_SOURCE,
EOBJECT__EVERY_BIDIRECTIONAL_REFERENCE_IS_PAIRED,
"_UI_UnpairedBidirectionalReference_diagnostic",
new Object[]
{
getFeatureLabel(eReference, context),
getObjectLabel(eObject, context),
getFeatureLabel(eOpposite, context),
getObjectLabel(oppositeEObject, context),
},
new Object[] { eObject, eReference, oppositeEObject, eOpposite },
context));
}
}
}
else
{
if (oppositeEObject.eGet(eOpposite) != eObject)
{
result = false;
if (diagnostics != null)
{
diagnostics.add
(createDiagnostic
(BasicDiagnostic.ERROR,
DIAGNOSTIC_SOURCE,
EOBJECT__EVERY_BIDIRECTIONAL_REFERENCE_IS_PAIRED,
"_UI_UnpairedBidirectionalReference_diagnostic",
new Object[]
{
getFeatureLabel(eReference, context),
getObjectLabel(eObject, context),
getFeatureLabel(eOpposite, context),
getObjectLabel(oppositeEObject, context),
},
new Object[] { eObject, eReference, oppositeEObject, eOpposite },
context));
}
}
}
}
}
return(result);
}
protected bool validate_KeyUnique
(EObject eObject, EReference eReference, DiagnosticChain diagnostics, Dictionary <object, object> context)
{
bool result = true;
Dictionary <List <Object>, EObject> keys = new Dictionary <List <Object>, EObject>();
List <EAttribute> eAttributes = eReference.eKeys;// (EAttribute[])((BasicEList <?>)eReference.getEKeys()).data();
List <EObject> values = (List <EObject>)eObject.eGet(eReference);
foreach (EObject value in values)
{
List <Object> key = new List <Object>();
for (int i = 0, size = eAttributes.Count; i < size; ++i)
{
EAttribute eAttribute = eAttributes[i];
if (eAttribute == null)
{
break;
}
else
{
key.Add(value.eGet(eAttribute));
}
}
EObject otherValue = null;
if (keys.ContainsKey(key))
{
otherValue = keys[key];
}
keys.Add(key, value);
if (otherValue != null)
{
result = false;
if (diagnostics == null)
{
break;
}
else
{
String uriFragmentSegment = ((InternalEObject)eObject).eURIFragmentSegment(eReference, value);
int index = uriFragmentSegment.IndexOf('[', 0);
if (index != -1)
{
uriFragmentSegment = uriFragmentSegment.Substring(index);
}
diagnostics.add
(createDiagnostic
(BasicDiagnostic.ERROR,
DIAGNOSTIC_SOURCE,
EOBJECT__EVERY_KEY_UNIQUE,
"_UI_DuplicateKey_diagnostic",
new Object[]
{
getFeatureLabel(eReference, context),
uriFragmentSegment,
getObjectLabel(value, context),
getObjectLabel(otherValue, context)
},
new Object[] { eObject, eReference, value, otherValue },
context));
}
}
}
return(result);
}
private void importConnectors()
{
int counter = 0;
//first eReferences and ActivityEdges
foreach (MocaNode refNode in ConnectorNodeToParent.Keys)
{
EA.Element parent = ConnectorNodeToParent[refNode];
if (refNode.Name == EClass.ReferencesChildNodeName)
{
if (hasGui)
{
ImportWorker.ReportProgress(1, new ProgressObject(ProgressBarType.Current, "Import EReference", ConnectorNodeToParent.Count));
}
else
{
Console.Out.WriteLine("SCALE:Import EReference for '" + parent.Name + "' %" + counter + "/" + ConnectorNodeToParent.Count + "#");
counter++;
}
EcoreImport.importERef(sqlRep.GetElementByID(parent.ElementID), refNode);
}
/* else if (refNode.Name == "ActivityEdge")
* {
* if (hasGui)
* ImportWorker.ReportProgress(1, new ProgressObject(ProgressBarType.Current, "Import ActivityEdge", ConnectorNodeToParent.Count));
*
* SdmImport.importActivityEdge(sqlRep.GetElementByID(parent.ElementID), refNode);
* }
*
* if (refNode.Name == SDMModelingMain.LinkVariableStereotype)
* {
* if (hasGui)
* ImportWorker.ReportProgress(1, new ProgressObject(ProgressBarType.Current, "Import LinkVariable", ReferenceGuidToClientTarget.Count));
*
* SdmImport.importLinkVariable(sqlRep.GetElementByID(parent.ElementID), refNode);
* }
* else if (refNode.Name == TGGModelingMain.TggLinkVariableStereotype)
* {
* if (hasGui)
* ImportWorker.ReportProgress(1, new ProgressObject(ProgressBarType.Current, "Import TGGLinkVariable", ReferenceGuidToClientTarget.Count));
*
* TggImport.importTGGLinkVariable(refNode, sqlRep.GetElementByID(parent.ElementID));
* }*/
}
counter = 0;
foreach (String refGuid in ReferenceGuidToClientTarget.Keys)
{
if (hasGui)
{
ImportWorker.ReportProgress(2, new ProgressObject(ProgressBarType.Current, "Save EReference and refresh Gui", ReferenceGuidToClientTarget.Count));
}
else
{
Console.Out.WriteLine("SCALE:Save EReference and Refresh Gui for '" + refGuid + "' %" + counter + "/" + ReferenceGuidToClientTarget.Count + "#");
counter++;
}
if (ReferenceGuidToClientTarget.ContainsKey(refGuid) &&
ReferenceGuidToReference.ContainsKey(refGuid))
{
EA.Connector con = ReferenceGuidToReference[refGuid];
con.Update();
MocaNode refsNode = ReferenceGuidToClientTarget[refGuid];
EReference eRef = new EReference(sqlRep.GetConnectorByID(con.ConnectorID), sqlRep);
eRef.deserializeFromMocaTree(refsNode);
if (con.Notes == "Switched")
{
cleanUpEA(con.ClientEnd, con.SupplierEnd, eRef);
con.Notes = "";
con.Update();
eRef.switchEnds();
}
else
{
cleanUpEA(con.SupplierEnd, con.ClientEnd, eRef);
}
con.Update();
eRef.setRealConnector(con);
eRef.Update();
MocaTaggableElements.Add(eRef);
}
}
}
