internal static ISet <CheckResultRelation1> Check(LL.MDE.DataModels.EnAr.Package p, string someString, LL.MDE.DataModels.EnAr.Package p2) { ISet <CheckResultRelation1> result = new HashSet <CheckResultRelation1>(); ISet <MatchDomainP> matchDomainPs = CheckDomainP(p); ISet <MatchDomainP2> matchDomainP2s = CheckDomainP2(p2); foreach (MatchDomainP matchDomainP in matchDomainPs) { foreach (MatchDomainP2 matchDomainP2 in matchDomainP2s) { string s = matchDomainP.s; LL.MDE.DataModels.EnAr.Element pe = matchDomainP.pe; LL.MDE.DataModels.EnAr.Connector c = matchDomainP.c; int target = matchDomainP.target; int source = matchDomainP.source; if (p2.Name == (s + "Other")) { CheckResultRelation1 checkonlysMatch = new CheckResultRelation1() { matchDomainP = matchDomainP, matchDomainP2 = matchDomainP2, }; result.Add(checkonlysMatch); } // End if } // End foreach } // End foreach return(result); }
internal void Enforce(ISet <CheckResultBlockProperty2StructureElement> result, LL.MDE.DataModels.XML.Tag structureElements) { foreach (CheckResultBlockProperty2StructureElement match in result) { // Extracting variables binded in source domains LL.MDE.DataModels.EnAr.Element parentEl = match.matchDomainParentEl.parentEl; long sid = match.matchDomainParentEl.sid; LL.MDE.DataModels.EnAr.Connector aggregation = match.matchDomainParentEl.aggregation; int cid = match.matchDomainParentEl.cid; LL.MDE.DataModels.EnAr.Element childEl = match.matchDomainParentEl.childEl; string id = match.matchDomainParentEl.id; string elName = match.matchDomainParentEl.elName; LL.MDE.DataModels.EnAr.Element classifierEl = match.matchDomainParentEl.classifierEl; string classifierName = match.matchDomainParentEl.classifierName; LL.MDE.DataModels.XML.Tag parentSeDecomposition = match.matchDomainParentSeDecomposition.parentSeDecomposition; // Assigning variables binded in the where clause string name = elName + ':' + classifierName; // Enforcing each enforced domain MatchDomainStructureElements targetMatchDomainStructureElements = EnforceStructureElements(name, id, structureElements); // Retrieving variables binded in the enforced domains LL.MDE.DataModels.XML.Tag fmStructureelement = targetMatchDomainStructureElements.fmStructureelement; LL.MDE.DataModels.XML.Tag fmSeDecomposition = targetMatchDomainStructureElements.fmSeDecomposition; LL.MDE.DataModels.XML.Tag longName1 = targetMatchDomainStructureElements.longName1; LL.MDE.DataModels.XML.Tag l41 = targetMatchDomainStructureElements.l41; LL.MDE.DataModels.XML.Attribute lAttr1 = targetMatchDomainStructureElements.lAttr1; LL.MDE.DataModels.XML.Attribute structureId = targetMatchDomainStructureElements.structureId; // Calling other relations as defined in the where clause new RelationCreateDecompositionLink(editor, transformation).CheckAndEnforce(structureId, parentSeDecomposition); new RelationBlockProperty2StructureElement(editor, transformation).CheckAndEnforce(childEl, fmSeDecomposition, structureElements); } }
internal static ISet <CheckResultBlockProperty2StructureElement> Check(LL.MDE.DataModels.EnAr.Element parentEl, LL.MDE.DataModels.XML.Tag parentSeDecomposition) { ISet <CheckResultBlockProperty2StructureElement> result = new HashSet <CheckResultBlockProperty2StructureElement>(); ISet <MatchDomainParentEl> matchDomainParentEls = CheckDomainParentEl(parentEl); ISet <MatchDomainParentSeDecomposition> matchDomainParentSeDecompositions = CheckDomainParentSeDecomposition(parentSeDecomposition); foreach (MatchDomainParentEl matchDomainParentEl in matchDomainParentEls) { foreach (MatchDomainParentSeDecomposition matchDomainParentSeDecomposition in matchDomainParentSeDecompositions) { long sid = matchDomainParentEl.sid; LL.MDE.DataModels.EnAr.Connector aggregation = matchDomainParentEl.aggregation; int cid = matchDomainParentEl.cid; LL.MDE.DataModels.EnAr.Element childEl = matchDomainParentEl.childEl; string id = matchDomainParentEl.id; string elName = matchDomainParentEl.elName; LL.MDE.DataModels.EnAr.Element classifierEl = matchDomainParentEl.classifierEl; string classifierName = matchDomainParentEl.classifierName; CheckResultBlockProperty2StructureElement checkonlysMatch = new CheckResultBlockProperty2StructureElement() { matchDomainParentEl = matchDomainParentEl, matchDomainParentSeDecomposition = matchDomainParentSeDecomposition, }; result.Add(checkonlysMatch); } // End foreach } // End foreach return(result); }
internal MatchDomainPo EnforcePo(CheckResultRelation1 checkresult, string s, string someString, int source, LL.MDE.DataModels.EnAr.Package po) { MatchDomainPo match = new MatchDomainPo(); LL.MDE.DataModels.EnAr.Package p = checkresult.matchDomainP.p; LL.MDE.DataModels.EnAr.Element pe = checkresult.matchDomainP.pe; LL.MDE.DataModels.EnAr.Connector c = checkresult.matchDomainP.c; LL.MDE.DataModels.EnAr.Package p2 = checkresult.matchDomainP2.p2; // Contructing po editor.AddOrSetInField(po, "Name", s + "Out"); LL.MDE.DataModels.EnAr.Element e = null; // Trying to resolve the object'e' globally using the transformation key transformation.ElementKeys.TryGetValue(new Tuple <string>(s + someString), out e); // If the object wasn't found globally, we try to find it locally if (e == null) { e = po.Elements.OfType <LL.MDE.DataModels.EnAr.Element>().FirstOrDefault(var865311109 => var865311109?.Name == s + someString); // If the object was found locally, we add it to the global cache if (e != null) { transformation.ElementKeys[new Tuple <string>(e?.Name)] = e; } // If the object still doesn't exist, we create it else { e = (LL.MDE.DataModels.EnAr.Element)editor.CreateNewObjectInField(po, "Elements"); // We add the created object to the global cache if (transformation.ElementKeys.ContainsKey(new Tuple <string>(e?.Name))) { throw new Exception("Two objects cannot have the same key"); } else { transformation.ElementKeys[new Tuple <string>(e?.Name)] = e; } } } // Contructing e editor.AddOrSetInField(e, "Name", s + someString); editor.AddOrSetInField(e, "Type", "Component"); LL.MDE.DataModels.EnAr.Connector con = null; con = (LL.MDE.DataModels.EnAr.Connector)editor.CreateNewObjectInField(e, "Connectors"); // Contructing con editor.AddOrSetInField(con, "SupplierID", source); editor.AddOrSetInField(con, "Type", "Dependency"); // Return newly binded variables match.po = po; match.e = e; match.con = con; return(match); }
private EnAr.Connector ConstructGeneralization(Ecore.IEClass superEClass, EnAr.Element clazz) { EnAr.Element superClass = ConstructClassifier(superEClass); EnAr.Connector inheritanceConnector = (EnAr.Connector)clazz.Connectors.AddNew("", "Connector"); inheritanceConnector.Type = "Generalization"; inheritanceConnector.ClientID = clazz.ElementID; inheritanceConnector.SupplierID = superClass.ElementID; inheritanceConnector.Update(); return(inheritanceConnector); }
private EnAr.Element ConstructClass(Ecore.IEClass eClass) { EnAr.Package parentPackage; EnAr.Element clazz; if (!eclassifier2Class.ContainsKey(eClass)) { parentPackage = ConstructMetamodelPackage(eClass.EPackage); clazz = (EnAr.Element)parentPackage.Elements.AddNew(eClass.Name, "Class"); eclassifier2Class[eClass] = clazz; clazz.Abstract = Bool2String(eClass.Abstract.GetValueOrDefault() || eClass.Interface.GetValueOrDefault()); // Manage normal super types foreach (Ecore.IEClass superEClass in eClass.ESuperTypes) { ConstructGeneralization(superEClass, clazz); } // Manage super types that possess type parameters foreach (Ecore.IEGenericType eGenericSuperType in eClass.EGenericSuperTypes) { if (eGenericSuperType.EClassifier != null) { EnAr.Connector generalization = ConstructGeneralization((Ecore.IEClass)eGenericSuperType.EClassifier, clazz); EA.Connector generalizationEa = explorer.GetEaObject(generalization); foreach (Ecore.IEGenericType eTypeArgument in eGenericSuperType.ETypeArguments) { ConstructTemplateBinding(eGenericSuperType, eTypeArgument, generalizationEa); } } } foreach (Ecore.IEStructuralFeature eStructuralFeature in eClass.EStructuralFeatures) { ConstructAttributeOrAssociation(eclassifier2Class[eClass], eStructuralFeature); } // eClass.EOperations //TODO } else { parentPackage = ePackage2Package[eClass.EPackage]; clazz = eclassifier2Class[eClass]; } parentPackage.Elements.Refresh(); parentPackage.Update(); clazz.Update(); clazz.Connectors.Refresh(); return(clazz); }
public string GetTaggedValue(EnAr.Connector connector, string tagName) { foreach (EnAr.ConnectorTag taggedValue in connector.TaggedValues) { if (EqualsNoCase(taggedValue.Name, tagName)) { return(taggedValue.Value); } } return(null); }
public Tuple <EnAr.ConnectorEnd, EnAr.Element> GetElementOppositeTo(EnAr.Element oneElement, EnAr.Connector connector) { if (connector.ClientID == oneElement.ElementID) { return(new Tuple <EnAr.ConnectorEnd, EnAr.Element>(connector.SupplierEnd, GetTargetElement(connector))); } if (connector.SupplierID == oneElement.ElementID) { return(new Tuple <EnAr.ConnectorEnd, EnAr.Element>(connector.ClientEnd, GetSourceElement(connector))); } throw new Exception("The provided element is not connected to the provided connector."); }
internal void Enforce(ISet <CheckResultRelation1> result, string someString, LL.MDE.DataModels.EnAr.Package po) { foreach (CheckResultRelation1 match in result) { // Extracting variables binded in source domains LL.MDE.DataModels.EnAr.Package p = match.matchDomainP.p; string s = match.matchDomainP.s; LL.MDE.DataModels.EnAr.Element pe = match.matchDomainP.pe; LL.MDE.DataModels.EnAr.Connector c = match.matchDomainP.c; int target = match.matchDomainP.target; int source = match.matchDomainP.source; LL.MDE.DataModels.EnAr.Package p2 = match.matchDomainP2.p2; // Enforcing each enforced domain MatchDomainPo targetMatchDomainPo = EnforcePo(s, someString, source, po); // Retrieving variables binded in the enforced domains LL.MDE.DataModels.EnAr.Element e = targetMatchDomainPo.e; LL.MDE.DataModels.EnAr.Connector con = targetMatchDomainPo.con; } }
public EnAr.Element GetTargetElement(EnAr.Connector c) { return(repository.AllElements.Find(element => c.SupplierID == element.ElementID)); }
private QVTBase.ITypedModel ConstructTypedModel(QVTRelations.IRelationalTransformation relationTransformation, EnAr.Connector qvtTransformationLinkConnector) { // We determine the typedmodel based on the FQN given on the connector string modelNameTag = explorer.GetTaggedValue(qvtTransformationLinkConnector, "modelName"); string metaModelNameTag = explorer.GetTaggedValue(qvtTransformationLinkConnector, "metaModelName"); string typedModelName = ""; string metamodelFQNOrAlias = ""; EMOF.IPackage metamodelPackage = null; if (!modelNameTag.IsNullOrEmpty()) { if (modelNameTag.Contains(':')) { string[] split = modelNameTag.Split(':'); typedModelName = split[0]; metamodelFQNOrAlias = split[1]; } else if (metaModelNameTag != null) { typedModelName = modelNameTag; } } if (metamodelFQNOrAlias.IsNullOrEmpty() && metaModelNameTag != null) { // Case real link if (metaModelNameTag.StartsWith("{")) { EnAr.Package enArMetamodelPackage = explorer.GetPackageByGuid(metaModelNameTag); metamodelPackage = emofImporter.GetEMOFPackage(enArMetamodelPackage); } // Case string name else { metamodelFQNOrAlias = metaModelNameTag; } } if (metamodelPackage == null) { // The metamodel package can be found either using the FQN or one of its aliases metamodelPackage = metamodels.FirstOrDefault(metamodel => EnArImporterEMOF.GetFQN(metamodel) == metamodelFQNOrAlias || (aliases.ContainsKey(metamodelFQNOrAlias) && metamodel == aliases[metamodelFQNOrAlias])); } /*if (typedModelName.IsNullOrEmpty() && metamodelPackage == null) * { * throw new InvalidQVTRelationsModelException("A domain link must either indicate the model name with the pattern <model name>:<metamodel name>, or must provide a tag 'metaModelName'.", qvtTransformationLinkConnector); * }*/ // Case primitive domains... could probably be managed better if (metamodelPackage == null) { return(null); } // We first check that the relational transformation doesn't already have this typed model QVTBase.ITypedModel typedModel = relationTransformation.ModelParameter.FirstOrDefault(p => (typedModelName.IsNullOrEmpty() || p.Name == typedModelName) && p.UsedPackage.FirstOrDefault(p2 => p2 == metamodelPackage) != null); // If there is none, we create one if (typedModel == null) { typedModel = new QVTBase.TypedModel() { Name = typedModelName, Transformation = relationTransformation, }; typedModel.UsedPackage.Add(metamodelPackage); } return(typedModel); }
private QVTRelations.IRelationDomain ConstructNonPrimitiveRelationDomain(QVTRelations.IRelation relation, QVTBase.ITypedModel typedModel, EnAr.Connector qvtTransformationLinkConnector, EnAr.Element domainObjectElement) { //if (domainObjectElement.Stereotype != "domain") // throw new InvalidQVTRelationsModelException("A domain element must have the \"domain\" stereotype", domainObjectElement); // TODO replace by warning? QVTRelations.RelationDomain relationDomain = new QVTRelations.RelationDomain() { Name = qvtTransformationLinkConnector.Name, IsCheckable = true, IsEnforceable = explorer.GetTaggedValue(qvtTransformationLinkConnector, "CEType").ToLower() == "enforce", TypedModel = typedModel, //DefaultAssignment = null // TODO Rule = relation }; QVTRelations.IDomainPattern domainpattern = ConstructDomainPattern(relation, domainObjectElement); relationDomain.Pattern = domainpattern; relationDomain.RootVariable = domainpattern.TemplateExpression.BindsTo; domainpattern.RelationDomain = relationDomain; return(relationDomain); }
private QVTRelations.IRelationDomain ConstructPrimitiveRelationDomain(QVTRelations.IRelation relation, EnAr.Connector qvtTransformationLinkConnector, EnAr.Element domainObjectElement) { EssentialOCL.IVariable variable = ConstructVariable(relation, domainObjectElement); QVTRelations.IRelationDomain relationDomain = new QVTRelations.RelationDomain { Name = qvtTransformationLinkConnector.Name, // a primitive domain is supposed not to have a name, but we use it for ordering IsCheckable = true, IsEnforceable = false, //DefaultAssignment = null // TODO? Rule = relation, RootVariable = variable }; relation.Variable.Add(variable); return(relationDomain); }
public EA.Connector GetEaObject(EnAr.Connector connector) { return(repositoryEa.GetConnectorByGuid(connector.ConnectorGUID)); }
public EnAr.Element GetSourceElement(EnAr.Connector c) { return(repository.AllElements.Find(element => c.ClientID == element.ElementID)); }
private QVTTemplate.IPropertyTemplateItem ConstructPropertyTemplateItem(QVTRelations.IRelation relation, QVTRelations.IDomainPattern domainPattern, QVTTemplate.IObjectTemplateExp objectTemplateExp, EnAr.Connector connector, EnAr.ConnectorEnd connectorEnd, EnAr.Element linkedElement, ISet <EnAr.Connector> visitedConnectors) { EssentialOCL.IOclExpression value; EMOF.IType type; QVTTemplate.IObjectTemplateExp targetObjectTemplateExp; ISet <EnAr.Connector> realVisitedConnectors = visitedConnectors ?? new HashSet <EnAr.Connector>(); ISet <EnAr.Connector> realVisitedConnectorsPropagated = new HashSet <EnAr.Connector>(realVisitedConnectors); realVisitedConnectorsPropagated.Add(connector); // Case cycle among object templates: simple variable expression if (objectElementToObjectTemplate.ContainsKey(linkedElement)) { targetObjectTemplateExp = objectElementToObjectTemplate[linkedElement]; EssentialOCL.IVariable existingVariable = targetObjectTemplateExp.BindsTo; value = new EssentialOCL.VariableExp() { ReferredVariable = existingVariable }; type = existingVariable.Type; } // Case no cycle; recursive creation of object template else { targetObjectTemplateExp = ConstructObjectTemplateExp(relation, domainPattern, linkedElement, realVisitedConnectorsPropagated); value = targetObjectTemplateExp; type = ((QVTTemplate.IObjectTemplateExp)value).BindsTo.Type; } EMOF.IProperty property = null; // If the connector end has a role, we use it to find the corresponding EMOF property if (!string.IsNullOrWhiteSpace(connectorEnd.Role)) { property = objectTemplateExp.ReferredClass.GetAllInheritedAttributes().Single(p => p.Name == connectorEnd.Role); } // If the connector end has no role (due to the else) // AND if we haven't visited the connector yet // AND if the connector has no roles whatsoever, we try to guess the type else if (!realVisitedConnectors.Contains(connector) && connector.ClientEnd.Role.IsNullOrEmpty() && connector.SupplierEnd.Role.IsNullOrEmpty()) { IList <EMOF.IProperty> candidateProperties = objectTemplateExp.ReferredClass.GetAllInheritedAttributes().Where(p => (p.Type as EMOF.IClass)?.GetAllSubTypes().Contains(type) ?? p.Type == type).ToList(); if (candidateProperties.Count == 0) { throw new InvalidQVTRelationsModelException("Relation " + relation.Name + ", invalid property connector between " + objectTemplateExp.BindsTo.Name + " and " + targetObjectTemplateExp.BindsTo.Name + ", no possible property", connector); } if (candidateProperties.Count > 1) { throw new InvalidQVTRelationsModelException("Relation " + relation.Name + ", ambiguous property connector between " + objectTemplateExp.BindsTo.Name + " and " + targetObjectTemplateExp.BindsTo.Name + ", cannot choose a property between the following: [" + string.Join(";", candidateProperties.Select(p => p.Name)) + "]", connector); } property = candidateProperties.Single(); } QVTTemplate.PropertyTemplateItem propertyTemplateItem = null; if (property != null) { propertyTemplateItem = new QVTTemplate.PropertyTemplateItem() { ReferredProperty = property, Value = value, IsOpposite = false, // TODO? ObjContainer = objectTemplateExp }; } return(propertyTemplateItem); }
private void ConstructRelationDomain(QVTRelations.IRelationalTransformation relationTransformation, QVTRelations.IRelation relation, EnAr.Connector qvtTransformationLinkConnector) { // We look in the EA "domain" Element pointed by the qvtTransformationLinkConnector EnAr.Element domainObjectElement = explorer.GetTargetElement(qvtTransformationLinkConnector); // We construct (or get) the typed model, if any QVTBase.ITypedModel candidateTypedModel = ConstructTypedModel(relationTransformation, qvtTransformationLinkConnector); // If no typed model, it must be a primitive type // TODO maybe check for a tag? if (candidateTypedModel == null) { ConstructPrimitiveRelationDomain(relation, qvtTransformationLinkConnector, domainObjectElement); return; } // Else, we construct a regular domain ConstructNonPrimitiveRelationDomain(relation, candidateTypedModel, qvtTransformationLinkConnector, domainObjectElement); }