internal static ISet <MatchDomainAlP> CheckDomainAlP(LL.MDE.DataModels.EnAr.Package alP)
{
ISet <MatchDomainAlP> result = new HashSet <MatchDomainAlP>();
LL.MDE.DataModels.EnAr.Element alPE = alP.Element;
LL.MDE.DataModels.EnAr.Package projectP = alP.ParentPackage();
if (alPE.Stereotype == "abstraction level" && alPE.ElementPackage() == alP)
{
string projectName = projectP.Name;
LL.MDE.DataModels.EnAr.Element projectPE = projectP.Element;
if (projectPE.Stereotype == "fctsys" && projectPE.ElementPackage() == projectP)
{
MatchDomainAlP match = new MatchDomainAlP()
{
alP = alP,
alPE = alPE,
projectP = projectP,
projectName = projectName,
projectPE = projectPE,
};
result.Add(match);
}
}
return(result);
}
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 <CheckResultEA2FMEA_Start> result, LL.MDE.DataModels.XML.XMLFile fmeaFile)
{
foreach (CheckResultEA2FMEA_Start match in result)
{
// Extracting variables binded in source domains
LL.MDE.DataModels.EnAr.Package alP = match.matchDomainAlP.alP;
LL.MDE.DataModels.EnAr.Element alPE = match.matchDomainAlP.alPE;
LL.MDE.DataModels.EnAr.Package projectP = match.matchDomainAlP.projectP;
string projectName = match.matchDomainAlP.projectName;
LL.MDE.DataModels.EnAr.Element projectPE = match.matchDomainAlP.projectPE;
// Assigning variables binded in the where clause
// Enforcing each enforced domain
MatchDomainFmeaFile targetMatchDomainFmeaFile = EnforceFmeaFile(projectName, fmeaFile);
// Retrieving variables binded in the enforced domains
LL.MDE.DataModels.XML.Tag msrfmea = targetMatchDomainFmeaFile.msrfmea;
LL.MDE.DataModels.XML.Tag fmProjectsTag = targetMatchDomainFmeaFile.fmProjectsTag;
LL.MDE.DataModels.XML.Tag fmProjectTag = targetMatchDomainFmeaFile.fmProjectTag;
LL.MDE.DataModels.XML.Tag fmStructureRefs = targetMatchDomainFmeaFile.fmStructureRefs;
LL.MDE.DataModels.XML.Tag longName1 = targetMatchDomainFmeaFile.longName1;
LL.MDE.DataModels.XML.Tag l41 = targetMatchDomainFmeaFile.l41;
LL.MDE.DataModels.XML.Attribute lAttr1 = targetMatchDomainFmeaFile.lAttr1;
LL.MDE.DataModels.XML.Tag fmStructureElementsTag = targetMatchDomainFmeaFile.fmStructureElementsTag;
LL.MDE.DataModels.XML.Tag fmStructures = targetMatchDomainFmeaFile.fmStructures;
// Calling other relations as defined in the where clause
new RelationProduct2Structure(editor, transformation).CheckAndEnforce(alP, fmStructureRefs, fmStructureElementsTag, fmStructures);
}
}
public List <EnAr.Element> GetChildrenElementsWithTypeAndStereotype(EnAr.Element element, string type,
string stereotype)
{
List <EnAr.Element> childrenWithType = GetChildrenElementsWithType(element, type);
return(childrenWithType.FindAll(e => EqualsNoCase(e.Stereotype, stereotype)));
}
internal static ISet <MatchDomainP> CheckDomainP(LL.MDE.DataModels.EnAr.Package p)
{
ISet <MatchDomainP> result = new HashSet <MatchDomainP>();
string s = p.Name;
LL.MDE.DataModels.EnAr.Element pe = p.Element;
if (pe.Stereotype == "st1")
{
foreach (LL.MDE.DataModels.EnAr.Connector c in pe.Connectors.OfType <LL.MDE.DataModels.EnAr.Connector>())
{
int target = c.SupplierID;
int source = c.ClientID;
MatchDomainP match = new MatchDomainP()
{
p = p,
s = s,
pe = pe,
c = c,
target = target,
source = source,
};
result.Add(match);
}
}
return(result);
}
private void ConstructBasicRelation(QVTRelations.IRelationalTransformation transformation, EnAr.Element relationElement)
{
// First we check if an empty relation doesn't already exist
QVTRelations.IRelation relation = FindRelation(transformation, relationElement.Name);
// If not, we create it
if (relation == null)
{
relation = new QVTRelations.Relation()
{
Name = relationElement.Name
};
transformation.Rule.Add(relation);
// We find the unique child EA elements with the stereotype "qvtTransformationNode"
List <EnAr.Element> transformationNodeElements = explorer.GetChildrenElementsWithTypeAndStereotype(relationElement, "class", "qvtTransformationNode");
EnAr.Element transformationNodeElement = transformationNodeElements.Single();
bool isTopRelation = explorer.GetTaggedValue(relationElement, "isTopRelation").ToLower() == "true";
relation.IsTopLevel = isTopRelation;
relation.Transformation = transformation;
relation.Overrides = null; // TODO
// We browse the EA Connectors with the stereotype "qvtTransformationLink", from the qvtTransformationNode
// We use the concrete syntax extension to order the domains
foreach (EnAr.Connector qvtTransformationLinkConnector in explorer.GetConnectorsWithSourceWithStereotype(transformationNodeElement, "qvtTransformationLink").OrderBy(c => c.Name))
{
ConstructRelationDomain(transformation, relation, qvtTransformationLinkConnector);
}
}
}
internal static ISet <CheckResultRootProperty2StructureElement> Check(LL.MDE.DataModels.EnAr.Package abstractionLevelP, LL.MDE.DataModels.XML.Tag parentSeDecomposition, LL.MDE.DataModels.XML.Tag stucture)
{
ISet <CheckResultRootProperty2StructureElement> result = new HashSet <CheckResultRootProperty2StructureElement>(); ISet <MatchDomainAbstractionLevelP> matchDomainAbstractionLevelPs = CheckDomainAbstractionLevelP(abstractionLevelP); ISet <MatchDomainParentSeDecomposition> matchDomainParentSeDecompositions = CheckDomainParentSeDecomposition(parentSeDecomposition); ISet <MatchDomainStucture> matchDomainStuctures = CheckDomainStucture(stucture); foreach (MatchDomainAbstractionLevelP matchDomainAbstractionLevelP in matchDomainAbstractionLevelPs)
{
foreach (MatchDomainParentSeDecomposition matchDomainParentSeDecomposition in matchDomainParentSeDecompositions)
{
foreach (MatchDomainStucture matchDomainStucture in matchDomainStuctures)
{
LL.MDE.DataModels.EnAr.Package bpP = matchDomainAbstractionLevelP.bpP;
LL.MDE.DataModels.EnAr.Element bpPE = matchDomainAbstractionLevelP.bpPE;
LL.MDE.DataModels.EnAr.Element childEl = matchDomainAbstractionLevelP.childEl;
string id = matchDomainAbstractionLevelP.id;
string elName = matchDomainAbstractionLevelP.elName;
long reid = matchDomainAbstractionLevelP.reid;
LL.MDE.DataModels.EnAr.Element classifierEl = matchDomainAbstractionLevelP.classifierEl;
string classifierName = matchDomainAbstractionLevelP.classifierName;
CheckResultRootProperty2StructureElement checkonlysMatch = new CheckResultRootProperty2StructureElement()
{
matchDomainAbstractionLevelP = matchDomainAbstractionLevelP, matchDomainParentSeDecomposition = matchDomainParentSeDecomposition, matchDomainStucture = matchDomainStucture,
};
result.Add(checkonlysMatch);
} // End foreach
} // 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);
}
}
private EnAr.Element ConstructPrimitiveType(Ecore.IEDataType eDataType)
{
if (!eclassifier2Class.ContainsKey(eDataType))
{
EnAr.Package parentPackage = ConstructMetamodelPackage(eDataType.EPackage);
EnAr.Element primitiveType = (EnAr.Element)parentPackage.Elements.AddNew(eDataType.Name, "Class");
eclassifier2Class[eDataType] = primitiveType;
primitiveType.Stereotype = "primitive";
if (ecorePrimitiveToEnAr.ContainsKey(eDataType.Name))
{
EnAr.TaggedValue tag =
(EnAr.TaggedValue)primitiveType.TaggedValues.AddNew("MOFPrimitiveType", "Tag");
tag.Value = ecorePrimitiveToEnAr[eDataType.Name];
tag.Update();
primitiveType.TaggedValues.Refresh();
}
parentPackage.Elements.Refresh();
parentPackage.Update();
parentPackage.Element.Update();
primitiveType.Update();
return(primitiveType);
}
return(eclassifier2Class[eDataType]);
}
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);
}
private void ConstructTemplateBinding(Ecore.IEGenericType eGenericType,
Ecore.IEGenericType ecoreTypeArgument, EA.Connector connectorEa)
{
int positionTypeArgument = eGenericType.ETypeArguments.IndexOf(ecoreTypeArgument);
Ecore.IETypeParameter typeParameter =
eGenericType.EClassifier.ETypeParameters[positionTypeArgument];
string bindedName = ecoreTypeArgument.EClassifier.Name;
EnAr.Element bindedClass = ConstructClassifier(ecoreTypeArgument.EClassifier);
dynamic templateBinding = connectorEa.TemplateBindings.AddNew(bindedName, "");
templateBinding.formalname = typeParameter.Name;
templateBinding.ActualGUID = bindedClass.ElementGUID;
try
{
templateBinding.Update();
}
catch (Exception)
{
// ignored
}
connectorEa.Update();
}
internal void Enforce(ISet <CheckResultProduct2Structure> result, LL.MDE.DataModels.XML.Tag fmStructures)
{
foreach (CheckResultProduct2Structure match in result)
{
// Extracting variables binded in source domains
LL.MDE.DataModels.EnAr.Package productP = match.matchDomainProductP.productP;
string productName = match.matchDomainProductP.productName;
LL.MDE.DataModels.EnAr.Element productPE = match.matchDomainProductP.productPE;
string productID = match.matchDomainProductP.productID;
LL.MDE.DataModels.XML.Tag fmStructureRefs = match.matchDomainFmStructureRefs.fmStructureRefs;
LL.MDE.DataModels.XML.Tag fmStructureElements = match.matchDomainFmStructureElements.fmStructureElements;
// Assigning variables binded in the where clause
// Enforcing each enforced domain
MatchDomainFmStructures targetMatchDomainFmStructures = EnforceFmStructures(productID, productName, fmStructures);
// Retrieving variables binded in the enforced domains
LL.MDE.DataModels.XML.Tag fmStructure = targetMatchDomainFmStructures.fmStructure;
LL.MDE.DataModels.XML.Attribute structureId = targetMatchDomainFmStructures.structureId;
LL.MDE.DataModels.XML.Tag longName1 = targetMatchDomainFmStructures.longName1;
LL.MDE.DataModels.XML.Tag l41 = targetMatchDomainFmStructures.l41;
LL.MDE.DataModels.XML.Attribute lAttr1 = targetMatchDomainFmStructures.lAttr1;
// Calling other relations as defined in the where clause
new RelationCreateProjectStructureLink(editor, transformation).CheckAndEnforce(structureId, fmStructureRefs); new RelationAddStructureRoot(editor, transformation).CheckAndEnforce(productP, fmStructure, fmStructureElements);
}
}
private EnAr.Element ConstructEnumeration(Ecore.IEEnum eEnum)
{
if (eclassifier2Class.ContainsKey(eEnum))
{
return(eclassifier2Class[eEnum]);
}
EnAr.Package parentPackage = ConstructMetamodelPackage(eEnum.EPackage);
EnAr.Element enumeration = (EnAr.Element)parentPackage.Elements.AddNew(eEnum.Name, "Enumeration");
eclassifier2Class[eEnum] = enumeration;
foreach (Ecore.IEEnumLiteral eEnumLiteral in eEnum.ELiterals)
{
EnAr.Attribute attributeLiteral =
(EnAr.Attribute)enumeration.Attributes.AddNew(eEnumLiteral.Name, "Attribute");
attributeLiteral.Stereotype = "enum";
attributeLiteral.LowerBound = "1";
attributeLiteral.UpperBound = "1";
attributeLiteral.IsCollection = false;
attributeLiteral.Update();
}
enumeration.Attributes.Refresh();
enumeration.Update();
enumeration.Refresh();
return(enumeration);
}
public QVTRelations.IRelationalTransformation ConstructRelationalTransformation(string transformatioName)
{
IList <EnAr.Element> transformationsElements = explorer.FindElementsWithTypeAndStereotype("component", "qvtTransformation");
EnAr.Element transfo = transformationsElements.Single(e => e.Name == transformatioName);
QVTRelations.IRelationalTransformation transformation = ConstructRelationalTransformation(transfo);
return(transformation);
}
private EMOF.IClass ConstructClass(EnAr.Element classElement)
{
// We create a EMOF.Class
EMOF.IClass clazz = new EMOF.Class()
{
IsAbstract = classElement.Abstract.ToLower() == "true", Name = classElement.Name
};
elementToType.Add(classElement, clazz);
// We browse the attributes of the EMOF.Class element (~= ecore attributes)
foreach (EnAr.Attribute attribute in explorer.GetAttributes(classElement))
{
EMOF.IProperty property = ConstructProperty(attribute);
property.Class = clazz;
clazz.OwnedAttribute.Add(property);
}
// We browse the connectors (~= ecore references + inheritance links)
foreach (EnAr.Connector connector in explorer.GetConnectorsWithSource(classElement))
{
EnAr.Element targetElement = explorer.GetTargetElement(connector);
if (targetElement.Type.ToLower() == "class")
{
EMOF.IClass targetType = ConstructType(targetElement) as EMOF.Class;
if (targetType != null)
{
// Case super type
if (connector.Type.ToLower() == "generalization")
{
clazz.SuperClass.Add(targetType);
}
// Case reference(s)
else
{
EMOF.IProperty prop1 = ConstructProperty(clazz, targetType, connector.ClientEnd, connector.SupplierEnd);
EMOF.IProperty prop2 = ConstructProperty(targetType, clazz, connector.SupplierEnd, connector.ClientEnd);
if (prop1 != null && prop2 != null)
{
prop1.Opposite = prop2;
prop2.Opposite = prop1;
}
}
}
}
}
// And finally the methods
foreach (EnAr.Method method in explorer.GetMethods(classElement))
{
EMOF.IOperation operation = ConstructOperation(method);
clazz.OwnedOperation.Add(operation);
operation.Class = clazz;
}
return(clazz);
}
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 void ConstructAttribute(EnAr.IElement clazz, Ecore.IEStructuralFeature eStructuralFeature)
{
EnAr.Attribute attribute = (EnAr.Attribute)clazz.Attributes.AddNew(eStructuralFeature.Name, "Attribute");
// Case regular type without template
if (eStructuralFeature.EType != null)
{
EnAr.Element attributeType = ConstructClassifier(eStructuralFeature.EType);
attribute.ClassifierID = attributeType.ElementID;
attribute.Type = attributeType.Name;
}
else if (eStructuralFeature.EGenericType != null)
{
Ecore.IEGenericType eGenericType = eStructuralFeature.EGenericType;
// Case templated type (eg. MyClass<T>)
if (eGenericType.EClassifier != null)
{
EnAr.Element attributeType = ConstructClassifier(eGenericType.EClassifier);
attribute.ClassifierID = attributeType.ElementID;
attribute.Type = attributeType.Name;
foreach (Ecore.IEGenericType eTypeArgument in eGenericType.ETypeArguments)
{
//TODO impossible to manage local bindings with regular attribute in EA, needs to be a reference/association?
}
}
// Case template type (eg. T), we simply set the same name
else if (eGenericType.ETypeParameter != null)
{
// TODO can we do better than that in EA?
attribute.Type = eGenericType.ETypeParameter.Name;
}
}
attribute.LowerBound = BoundToString(eStructuralFeature.LowerBound.GetValueOrDefault());
attribute.UpperBound = BoundToString(eStructuralFeature.UpperBound.GetValueOrDefault());
if (eStructuralFeature.UpperBound.GetValueOrDefault() == -1 ||
eStructuralFeature.UpperBound.GetValueOrDefault() > 1)
{
attribute.IsOrdered = eStructuralFeature.Ordered.GetValueOrDefault();
}
attribute.AllowDuplicates = !eStructuralFeature.Unique.GetValueOrDefault();
attribute.IsDerived = eStructuralFeature.Derived.GetValueOrDefault();
attribute.IsConst = !eStructuralFeature.Changeable.GetValueOrDefault();
attribute.IsCollection = eStructuralFeature.UpperBound == -1 || eStructuralFeature.UpperBound > 1;
attribute.Default = eStructuralFeature.DefaultValueLiteral;
clazz.Attributes.Refresh();
attribute.Update();
}
public List <EnAr.Element> GetChildrenElements(EnAr.Element element)
{
if (EqualsNoCase(element.Type, "package"))
{
return(GetChildrenElements(FindPackage(element)));
}
else
{
return(repository.AllElements.FindAll(e => e.ParentID == element.ElementID));
}
}
public string GetTaggedValue(EnAr.Element element, String tagName)
{
foreach (EnAr.TaggedValue taggedValue2 in element.TaggedValues)
{
if (EqualsNoCase(taggedValue2.Name, tagName))
{
return(taggedValue2.Value);
}
}
return(null);
}
public static List <RunStateField> GetRunState(EnAr.Element element)
{
List <RunStateField> result = new List <RunStateField>();
string[] tokens = element.RunState.Split(';');
const string variableString = "Variable";
const string valueString = "Value";
const string opString = "Op";
const string noteString = "Note";
RunStateField currentRunStateField = null;
foreach (string token in tokens)
{
if (token == "@VAR")
{
currentRunStateField = new RunStateField();
}
else if (token == "@ENDVAR")
{
result.Add(currentRunStateField);
}
else if (token.StartsWith(variableString))
{
if (currentRunStateField != null)
{
currentRunStateField.Variable = token.Substring(variableString.Length + 1);
}
}
else if (token.StartsWith(valueString))
{
if (currentRunStateField != null)
{
currentRunStateField.Value = token.Substring(valueString.Length + 1);
}
}
else if (token.StartsWith(opString))
{
if (currentRunStateField != null)
{
currentRunStateField.Operator = token.Substring(opString.Length + 1);
}
}
else if (token.StartsWith(noteString))
{
if (currentRunStateField != null)
{
currentRunStateField.Notes = token.Substring(noteString.Length + 1);
}
}
}
return(result);
}
public EMOF.IType ConstructTypeOfTyped(EnAr.Attribute typedAttribute)
{
EnAr.Element typeElement = explorer.GetClassElement(typedAttribute);
if (typeElement != null)
{
return(ConstructType(typeElement));
}
else
{
return(ConstructPrimitiveType(typedAttribute.Type));
}
}
public List <EnAr.Attribute> GetAttributes(EnAr.Element classElement)
{
List <EnAr.Attribute> result = new List <EnAr.Attribute>();
foreach (object attribute in classElement.Attributes)
{
if (attribute is EnAr.Attribute)
{
result.Add(attribute as EnAr.Attribute);
}
}
return(result);
}
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.");
}
public List <EnAr.Method> GetMethods(EnAr.Element e)
{
List <EnAr.Method> result = new List <EnAr.Method>();
foreach (object method in e.Methods)
{
if (method is EnAr.Method)
{
result.Add(method as EnAr.Method);
}
}
return(result);
}
public EMOF.IType ConstructTypeOfParameter(EnAr.Parameter parameter)
{
if (parameter.Type == null)
{
return(null);
}
EnAr.Element returnType = explorer.repository.GetElementByGuid(parameter.Type);
if (returnType != null)
{
return(ConstructType(returnType));
}
else
{
return(ConstructPrimitiveType(parameter.Type));
}
}
public EMOF.IType ConstructTypeOfMethod(EnAr.Method method)
{
if (method.ReturnType == null)
{
return(null);
}
EnAr.Element returnType = explorer.repository.GetElementByGuid(method.ReturnType);
if (returnType != null)
{
return(ConstructType(returnType));
}
else
{
return(ConstructPrimitiveType(method.ReturnType));
}
}
internal void CheckAndEnforce(LL.MDE.DataModels.EnAr.Element parentEl, LL.MDE.DataModels.XML.Tag parentSeDecomposition, LL.MDE.DataModels.XML.Tag structureElements)
{
CheckOnlyDomains input = new CheckOnlyDomains(parentEl, parentSeDecomposition);
EnforceDomains output = new EnforceDomains(structureElements);
if (traceabilityMap.ContainsKey(input) && !traceabilityMap[input].Equals(output))
{
throw new Exception("This relation has already been used with different enforced parameters!");
}
if (!traceabilityMap.ContainsKey(input))
{
ISet <CheckResultBlockProperty2StructureElement> result = Check(parentEl, parentSeDecomposition);
Enforce(result, structureElements);
traceabilityMap[input] = output;
}
}
internal static ISet <CheckResultEA2FMEA_Start> Check(LL.MDE.DataModels.EnAr.Package alP)
{
ISet <CheckResultEA2FMEA_Start> result = new HashSet <CheckResultEA2FMEA_Start>(); ISet <MatchDomainAlP> matchDomainAlPs = CheckDomainAlP(alP); foreach (MatchDomainAlP matchDomainAlP in matchDomainAlPs)
{
LL.MDE.DataModels.EnAr.Element alPE = matchDomainAlP.alPE;
LL.MDE.DataModels.EnAr.Package projectP = matchDomainAlP.projectP;
string projectName = matchDomainAlP.projectName;
LL.MDE.DataModels.EnAr.Element projectPE = matchDomainAlP.projectPE;
CheckResultEA2FMEA_Start checkonlysMatch = new CheckResultEA2FMEA_Start()
{
matchDomainAlP = matchDomainAlP,
};
result.Add(checkonlysMatch);
} // End foreach
return(result);
}
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);
}