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);
}
