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 void LoadXMLType()
{
EPackage package = EcoreInterop.LoadPackageFromFile("XMLTypeTest.ecore");
Assert.IsNotNull(package);
var xmlTypeNamespace = EcoreInterop.Transform2Meta(package);
Assert.IsNotNull(xmlTypeNamespace);
var DataTypes = xmlTypeNamespace.Types.OfType <IClass>().FirstOrDefault(t => t.Name == "DataTypes");
Assert.IsNotNull(DataTypes);
AssertAttribute(DataTypes, "AnySimpleType", typeof(object));
AssertAttribute(DataTypes, "AnyURI", typeof(string));
AssertAttribute(DataTypes, "Base64Binary", typeof(byte[]));
AssertAttribute(DataTypes, "Boolean", typeof(bool));
AssertAttribute(DataTypes, "Byte", typeof(byte));
AssertAttribute(DataTypes, "Date", typeof(object));
AssertAttribute(DataTypes, "DateTime", typeof(object));
//AssertAttribute(DataTypes, "Decimal", typeof(java.math.BigDecimal));
AssertAttribute(DataTypes, "Double", typeof(double));
AssertAttribute(DataTypes, "Duration", typeof(object));
//AssertAttribute(DataTypes, "ENTITIES", typeof(java.util.List));
AssertAttribute(DataTypes, "ENTITY", typeof(string));
AssertAttribute(DataTypes, "Float", typeof(float));
AssertAttribute(DataTypes, "GDay", typeof(object));
AssertAttribute(DataTypes, "GMonth", typeof(object));
AssertAttribute(DataTypes, "GMonthDay", typeof(object));
AssertAttribute(DataTypes, "GYear", typeof(object));
AssertAttribute(DataTypes, "GYearMonth", typeof(object));
AssertAttribute(DataTypes, "HexBinary", typeof(byte[]));
AssertAttribute(DataTypes, "ID", typeof(string));
AssertAttribute(DataTypes, "IDREF", typeof(string));
//AssertAttribute(DataTypes, "IDREFS", typeof(java.util.List));
AssertAttribute(DataTypes, "Int", typeof(int));
//AssertAttribute(DataTypes, "Integer", typeof(java.math.BigInteger));
AssertAttribute(DataTypes, "Language", typeof(string));
AssertAttribute(DataTypes, "Long", typeof(long));
AssertAttribute(DataTypes, "Name", typeof(string));
AssertAttribute(DataTypes, "NCName", typeof(string));
//AssertAttribute(DataTypes, "NegativeInteger", typeof(java.math.BigInteger));
AssertAttribute(DataTypes, "NMToken", typeof(string));
//AssertAttribute(DataTypes, "NMTOKENS", typeof(java.util.List));
//AssertAttribute(DataTypes, "NonNegativeInteger", typeof(java.math.BigInteger));
//AssertAttribute(DataTypes, "NonPositiveInteger", typeof(java.math.BigInteger));
AssertAttribute(DataTypes, "NormalizedString", typeof(string));
AssertAttribute(DataTypes, "NOTATION", typeof(object));
//AssertAttribute(DataTypes, "PositiveInteger", typeof(java.math.BigInteger));
AssertAttribute(DataTypes, "QName", typeof(object));
AssertAttribute(DataTypes, "Short", typeof(short));
AssertAttribute(DataTypes, "String", typeof(string));
AssertAttribute(DataTypes, "Time", typeof(object));
AssertAttribute(DataTypes, "Token", typeof(string));
AssertAttribute(DataTypes, "UnsignedByte", typeof(short));
AssertAttribute(DataTypes, "UnsignedInt", typeof(long));
//AssertAttribute(DataTypes, "UnsignedLong", typeof(java.math.BigInteger));
AssertAttribute(DataTypes, "UnsignedShort", typeof(int));
}
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);
}
public static EPackage GenerateModel2()
{
var package = new EPackage
{
Name = "model2",
NsPrefix = "model2",
NsURI = "http://www.transformation-tool-contest.eu/2017/LiveContest/testModels/model2"
};
var classA = new EClass {
Name = "A"
};
var classB = new EClass {
Name = "B"
};
var classC = new EClass {
Name = "C"
};
var classD = new EClass {
Name = "D"
};
var classE = new EClass {
Name = "E"
};
classA.EStructuralFeatures.Add(new EReference
{
Name = "PropA",
EType = classE
});
classB.EStructuralFeatures.Add(new EReference
{
Name = "PropB",
EType = classE,
Refines = classA.EStructuralFeatures[0] as IEReference
});
classC.EStructuralFeatures.Add(new EReference
{
Name = "PropC",
EType = classE
});
classD.EStructuralFeatures.Add(new EReference
{
Name = "PropD",
EType = classE
});
classB.ESuperTypes.Add(classA);
classC.ESuperTypes.Add(classA);
classD.ESuperTypes.Add(classB);
classD.ESuperTypes.Add(classC);
package.EClassifiers.Add(classA);
package.EClassifiers.Add(classB);
package.EClassifiers.Add(classC);
package.EClassifiers.Add(classD);
package.EClassifiers.Add(classE);
return(package);
}
private void ConvertPackage(MetaNamespaceBuilder parentNs, EPackage epkg)
{
var mns = _factory.MetaNamespace();
mns.Name = epkg.Name.ToPascalCase();
mns.Namespace = parentNs;
_map.Add(epkg, mns);
if (epkg.NsURI != null)
{
var metaModel = _factory.MetaModel();
metaModel.Name = epkg.Name.ToPascalCase();
metaModel.Prefix = epkg.NsPrefix;
metaModel.Uri = epkg.NsURI;
mns.DefinedMetaModel = metaModel;
}
foreach (var childEpgk in epkg.ESubPackages)
{
ConvertPackage(mns, childEpgk);
}
foreach (var childClsf in epkg.EClassifiers)
{
ConvertClassifier(mns, childClsf);
}
BindSuperClasses();
BindTypedElements();
CreateAssociations();
}
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);
}
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);
}
}
}
}
private static void GenerateCodeFor(string input, string output, string name)
{
EPackage package = EcoreInterop.LoadPackageFromFile(input);
INamespace nMeta = EcoreInterop.Transform2Meta(package);
CodeCompileUnit code = MetaFacade.CreateCode(nMeta, name);
MetaFacade.GenerateCode(code, new CSharpCodeProvider(), output, true);
}
/// <summary>
/// ドメインオブジェクト
/// DBに依存するレイヤー(Infrastructureレイヤー)に定義する。
/// DBに依存する処理を記述する
/// </summary>
/// <param name="value"></param>
public Package(string value)
{
EPackage temp;
if (false == Enum.TryParse(value, true, out temp))
{
return;
}
this.package = temp;
}
private String computeRootNodeName(EPackage package)
{
SQLPackage curPackage = package.EaPackage;
while (curPackage.ParentID != 0)
{
curPackage = package.Repository.GetPackageByID(curPackage.ParentID);
}
return(curPackage.Name);
}
public static INamespace Transform2Meta(EPackage package)
{
var model = new Model();
var rootPackage = TransformationEngine.Transform<IEPackage, INamespace>(package, ecore2Meta);
model.RootElements.Add(rootPackage);
Uri modelUri;
if (Uri.TryCreate(package.NsURI, UriKind.Absolute, out modelUri))
{
model.ModelUri = modelUri;
}
return rootPackage;
}
private static void GenerateExampleModel(EPackage model)
{
repository.Save(model, $"models\\{model.Name}.xmi");
var model_codeA = TransformationEngine.Transform <IEPackage, Package>(model, codeGenA);
var model_codeB = TransformationEngine.Transform <IEPackage, Package>(model, codeGenB);
repository.Save(model_codeA, $"expected_results\\{model.Name}_codeA.xmi");
repository.Save(model_codeB, $"expected_results\\{model.Name}_codeB.xmi");
printer.Print(model_codeA, $"expected_results\\{model.Name}_codeA.txt");
printer.Print(model_codeB, $"expected_results\\{model.Name}_codeB.txt");
}
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);
}
}
private MocaNode processEPackage(SQLPackage eaPackage)
{
SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaPackage, Main.MoflonExportTreeTaggedValueName);
if (mocaTreeTag != null)
{
EPackage ePackage = new EPackage(eaPackage, repository);
MocaNode ePackageMocaNode = MocaTreeUtil.mocaNodeFromXmlString(mocaTreeTag.Notes);
SQLTaggedValue changesTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaPackage, Main.MoflonChangesTreeTaggedValueName);
if (changesTreeTag != null)
{
MocaNode ePackageChangesMocaNode = MocaTreeUtil.mocaNodeFromXmlString(changesTreeTag.Notes);
if (ePackageChangesMocaNode.hasAllAttributes(new List <string>(
new string[] { ChangesTreeConstants.ATTRIBUTE_KEY_PACKAGE_NAME, ChangesTreeConstants.ATTRIBUTE_KEY_PROJECT_NAME })))
{
ePackage.addChangesAttributesDuringExport(ePackageMocaNode, changesTreeTag);
CachedPackage temp = new CachedPackage();
temp.getPackage(eaPackage.PackageGUID, repository);
temp.name = eaPackage.Name;
temp.previousName = eaPackage.Name;
temp.packageName = ePackageChangesMocaNode.getAttribute(ChangesTreeConstants.ATTRIBUTE_KEY_PACKAGE_NAME).Value;
temp.projectName = ePackageChangesMocaNode.getAttribute(ChangesTreeConstants.ATTRIBUTE_KEY_PROJECT_NAME).Value;
temp.savePackageToEATaggedValue(true);
}
}
ePackage.addAttributesDuringExport(ePackageMocaNode);
this.currentNode.appendChildNode(ePackageMocaNode);
foreach (SQLElement childClass in eaPackage.Elements)
{
this.currentNode = ePackageMocaNode.getChildNodeWithName(EPackageHelper.ClassesChildNodeName);
if (childClass.Stereotype.ToLower() == ECOREModelingMain.EClassStereotype.ToLower())
{
processEClass(childClass);
}
}
foreach (SQLPackage childPackage in eaPackage.Packages)
{
this.currentNode = ePackageMocaNode.getChildNodeWithName(EPackageHelper.PackagesChildNodeName);
processEPackage(childPackage);
}
return(ePackageMocaNode);
}
return(null);
}
private MocaNode processEPackage(SQLPackage eaPackage)
{
backgroundWorker.ReportProgress(0, PersistencyUtil.computePackageUri(eaPackage, repository));
SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaPackage, Main.MoflonExportTreeTaggedValueName);
if (mocaTreeTag != null)
{
EPackage ePackage = new EPackage(eaPackage, repository);
MocaNode ePackageMocaNode = MocaTreeUtil.mocaNodeFromXmlString(mocaTreeTag.Notes);
ePackage.addAttributesDuringExport(ePackageMocaNode);
this.currentNode.appendChildNode(ePackageMocaNode);
int counter = 0;
foreach (SQLElement childClass in eaPackage.Elements)
{
if (!Export.showStatusBar)
{
Console.Out.WriteLine("SCALE:Export Classifier '" + childClass.Name + "' %" + counter + "/" + eaPackage.Elements.Count + "#");
}
counter++;
this.currentNode = ePackageMocaNode.getChildNodeWithName(EPackageHelper.ClassesChildNodeName);
if (childClass.Stereotype.ToLower() == ECOREModelingMain.EClassStereotype.ToLower())
{
processEClass(childClass);
}
else if (childClass.Stereotype.ToLower() == ECOREModelingMain.EDatatypeStereotype.ToLower())
{
processEDatatype(childClass);
}
else if (childClass.Stereotype.ToLower() == ECOREModelingMain.EEnumStereotype.ToLower())
{
processEEnum(childClass);
}
}
foreach (SQLPackage childPackage in eaPackage.Packages)
{
this.currentNode = ePackageMocaNode.getChildNodeWithName(EPackageHelper.PackagesChildNodeName);
processEPackage(childPackage);
}
return(ePackageMocaNode);
}
return(null);
}
public override void eSet(int featureID, object newValue)
{
switch (featureID)
{
case EcorePackageImpl.EFACTORY_EANNOTATIONS:
eAnnotations.Clear();
eAnnotations.AddRange(((List <EObject>)newValue)?.Cast <EAnnotation>());
return;
case EcorePackageImpl.EFACTORY_EPACKAGE:
ePackage = (EPackage)newValue;
return;
}
base.eSet(featureID, newValue);
}
public void EA_OnPostNewDiagram(EA.Repository Repository, EA.EventProperties Info)
{
SQLRepository sqlRep = new SQLRepository(Repository, false);
EA.Diagram diagram = Repository.GetDiagramByID(int.Parse((string)Info.Get(0).Value));
if (ECOREModelingMain.EcoreDiagramMetatype.Contains(diagram.MetaType))
{
EA.Package package = Repository.GetPackageByID(diagram.PackageID);
if (package.Diagrams.Count == 1 && (package.StereotypeEx == "" || package.StereotypeEx == "EPackage"))
{
EPackage epackage = new EPackage(sqlRep.GetPackageByID(package.PackageID), sqlRep);
epackage.saveTreeToEATaggedValue(true);
}
}
}
private void updateMocaTreeFragments()
{
// For all packages (recursively!) in TGG and Ecore projects
foreach (EA.Package p in EAUtil.findAllMoflonPackages(repository))
{
SQLPackage p2 = sqlRep.GetPackageByID(p.PackageID);
if (p.Element.Stereotype == TGGModelingMain.TggSchemaPackageStereotype)
{
TGG tgg = new TGG(sqlRep, p2);
tgg.loadTreeFromTaggedValue();
tgg.saveTreeToEATaggedValue(false);
}
else if (p.Element.Stereotype == TGGModelingMain.TggRulePackageStereotype)
{
TGGRulePackage package = new TGGRulePackage(p2, sqlRep);
package.loadTreeFromTaggedValue();
package.saveTreeToEATaggedValue(false);
}
else
{
EPackage package = new EPackage(p2, sqlRep);
package.loadTreeFromTaggedValue();
package.saveTreeToEATaggedValue(false);
}
}
foreach (EA.Element eClassElement in EAUtil.findAllEClasses(repository))
{
EClass eClass = new EClass(sqlRep.GetElementByID(eClassElement.ElementID), sqlRep);
eClass.saveTreeToEATaggedValue(false);
}
foreach (EA.Element ruleElement in EAUtil.findAllStereotypedElements(repository, TGGModelingMain.TggRuleStereotype))
{
TGGRule rule = new TGGRule(sqlRep, sqlRep.GetElementByID(ruleElement.ElementID));
rule.loadTreeFromTaggedValue();
rule.saveTreeToEATaggedValue(false);
}
foreach (EA.Element corrTypeElement in EAUtil.findAllStereotypedElements(repository, TGGModelingMain.TggCorrespondenceTypeStereotype))
{
TGGCorrespondenceType corrType = new TGGCorrespondenceType(sqlRep.GetElementByID(corrTypeElement.ElementID), sqlRep);
corrType.loadTreeFromTaggedValue();
corrType.saveTreeToEATaggedValue(false);
}
}
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 NotificationChain basicSetEPackage(EPackage newobj, NotificationChain msgs)
{
var oldobj = _ePackage;
_ePackage = newobj;
if (eNotificationRequired())
{
var notification = new ENotificationImpl(this, NotificationImpl.SET, EcorePackageImpl.EFACTORY_EPACKAGE, oldobj, newobj);
if (msgs == null)
{
msgs = notification;
}
else
{
msgs.add(notification);
}
}
return(msgs);
}
private void updateToStandardTaggedValues()
{
// For all packages (recursively!) in TGG and Ecore projects
// Create new set of tagged values if not already present and set to default value
foreach (EA.Package p in EAUtil.findAllMoflonPackages(repository))
{
SQLPackage p2 = sqlRep.GetPackageByID(p.PackageID);
EPackage package = new EPackage(p2, sqlRep);
package.updateToStandardTaggedValues();
}
/* deleteOldOvTaggedValues(SDMModelingMain.ObjectVariableStereotype);
* deleteOldOvTaggedValues(TGGModelingMain.TggObjectVariableStereotype);
* deleteOldOvTaggedValues(TGGModelingMain.TggCorrespondenceStereotype);
*
* deleteOlvLvTaggedValues(SDMModelingMain.LinkVariableStereotype);
* deleteOlvLvTaggedValues(TGGModelingMain.TggLinkVariableStereotype);
*/
}
private String addPackageName(EPackage epackage, String path, SQLRepository repository)
{
if (path.Equals(""))
{
path = epackage.Name;
}
else
{
path = epackage.Name + "." + path;
}
int parentID = epackage.EaPackage.ParentID;
SQLPackage parent = repository.GetPackageByID(parentID);
if (parent.IsModel)
{
EPackage parentEPackage = new EPackage(parent, repository);
return(addPackageName(parentEPackage, path, repository));
}
return(path);
}
public void TestSerializedName()
{
EPackage package = EcoreInterop.LoadPackageFromFile("EcoreXMLSchemaTest.ecore");
Assert.IsNotNull(package);
ns = EcoreInterop.Transform2Meta(package);
Assert.IsNotNull(ns);
/* Check Types */
var AnnotationDefaultsType = ns.Types.OfType <IClass>().FirstOrDefault(t => t.Name == "AnnotationDefaultsType");
AssertSerializationName(AnnotationDefaultsType, "AnnotationDefaults");
var PType = ns.Types.OfType <IClass>().FirstOrDefault(t => t.Name == "PType");
AssertSerializationName(PType, "P");
var ModelInformation = ns.Types.OfType <IClass>().FirstOrDefault(t => t.Name == "ModelInformation");
AssertNoSerializationName(ModelInformation);
/* Check References */
var pRef = AnnotationDefaultsType.References.FirstOrDefault(r => r.Name == "p");
AssertSerializationName(pRef, "P");
/* Check Attributes */
var valueAttr = PType.Attributes.FirstOrDefault(a => a.Name == "value");
AssertDefaultProperty(valueAttr);
var sizeAttr = PType.Attributes.FirstOrDefault(a => a.Name == "size");
AssertSerializationName(sizeAttr, "size");
var mixedAttr = ModelInformation.Attributes.FirstOrDefault(a => a.Name == "mixed");
AssertNoSerializationName(mixedAttr);
}
private MocaNode processTggPackage(SQLPackage eaPackage)
{
backgroundWorker.ReportProgress(0, PersistencyUtil.computePackageUri(eaPackage, repository));
EPackage ePackage = new EPackage(eaPackage, repository);
if (eaPackage.Element.Stereotype == TGGModelingMain.TggRulePackageStereotype || eaPackage.Name == "Rules")
{
ePackage = new TGGRulePackage(eaPackage, repository);
}
ePackage.loadTreeFromTaggedValue();
SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaPackage, Main.MoflonExportTreeTaggedValueName);
XmlDocument xmlDoc = MocaTreeUtil.stringToXmlDocument(mocaTreeTag.Notes);
MocaNode ePackageMocaNode = new MocaNode();
ePackageMocaNode.deserializeFromXmlTree(xmlDoc.DocumentElement.FirstChild as XmlElement);
ePackage.addAttributesDuringExport(ePackageMocaNode);
this.currentNode.appendChildNode(ePackageMocaNode);
foreach (SQLPackage childPackage in eaPackage.Packages)
{
this.currentNode = ePackageMocaNode.getChildNodeWithName(EPackageHelper.PackagesChildNodeName);
processTggPackage(childPackage);
}
foreach (SQLElement childClass in eaPackage.Elements)
{
processTGGPackageFeatures(ePackageMocaNode, childClass);
}
return(ePackageMocaNode);
}
public bool validateEPackage(EPackage 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);
}
public DeclarePackage(EPackage package)
{
Package = package;
}
protected abstract bool isSwitchFor(EPackage ePackage);
protected override bool isSwitchFor(EPackage ePackage)
{
return(ePackage == modelPackage);
}
public NotificationChain basicSetEPackage(EPackage newobj, NotificationChain msgs)
{
msgs = eBasicSetContainer((InternalEObject)newobj, EcorePackageImpl.ECLASSIFIER_EPACKAGE, msgs);
return(msgs);
}
/// <summary>
/// Sets the package.
/// </summary>
public void SetPackage(EPackage package)
{
_package = package;
}
/// <summary>
/// Combines device, speed grade and package to a part name.
/// </summary>
public static string MakePartName(EDevice device, ESpeedGrade grade, EPackage package)
{
return device.ToString() +
PropEnum.ToString(grade, EPropAssoc.ISE) + "-" +
package.ToString();
}
/// <summary>
/// Combines device, speed grade and package to a part name.
/// </summary>
public static string MakePartName(EDevice device, ESpeedGrade grade, EPackage package)
{
return(device.ToString() +
PropEnum.ToString(grade, EPropAssoc.ISE) + "-" +
package.ToString());
}
public static string getPackageURI(SQLRepository repository, SQLPackage pkg)
{
EPackage epackage = new EPackage(pkg, repository);
return(epackage.NsURI);
}
public DeclarePackage(EPackage package)
{
Package = package;
}
