internal void Enforce(ISet <CheckResultRootProperty2StructureElement> result, LL.MDE.DataModels.XML.Tag structureElements)
{
foreach (CheckResultRootProperty2StructureElement match in result)
{
// Extracting variables binded in source domains
LL.MDE.DataModels.EnAr.Package abstractionLevelP = match.matchDomainAbstractionLevelP.abstractionLevelP;
LL.MDE.DataModels.EnAr.Package bpP = match.matchDomainAbstractionLevelP.bpP;
LL.MDE.DataModels.EnAr.Element bpPE = match.matchDomainAbstractionLevelP.bpPE;
LL.MDE.DataModels.EnAr.Element childEl = match.matchDomainAbstractionLevelP.childEl;
string id = match.matchDomainAbstractionLevelP.id;
string elName = match.matchDomainAbstractionLevelP.elName;
long reid = match.matchDomainAbstractionLevelP.reid;
LL.MDE.DataModels.EnAr.Element classifierEl = match.matchDomainAbstractionLevelP.classifierEl;
string classifierName = match.matchDomainAbstractionLevelP.classifierName;
LL.MDE.DataModels.XML.Tag parentSeDecomposition = match.matchDomainParentSeDecomposition.parentSeDecomposition;
LL.MDE.DataModels.XML.Tag stucture = match.matchDomainStucture.stucture;
// Assigning variables binded in the where clause
string name = elName + ':' + classifierName;
// Enforcing each enforced domain
MatchDomainStructureElements targetMatchDomainStructureElements = EnforceStructureElements(id, name, 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.Attribute structureId = targetMatchDomainStructureElements.structureId;
LL.MDE.DataModels.XML.Tag longName1 = targetMatchDomainStructureElements.longName1;
LL.MDE.DataModels.XML.Tag l41 = targetMatchDomainStructureElements.l41;
LL.MDE.DataModels.XML.Attribute lAttr1 = targetMatchDomainStructureElements.lAttr1;
// 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 <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);
}
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 <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);
}
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);
}
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);
}
private EMOF.IPackage ConstructPackage(EnAr.Package metamodelPackage)
{
if (elementToPackage.ContainsKey(metamodelPackage))
{
return(elementToPackage[metamodelPackage]);
}
else
{
// We create the Package
EMOF.IPackage package = new EMOF.Package()
{
Name = metamodelPackage.Name
};
elementToPackage.Add(metamodelPackage, package);
// We create its owned Types
foreach (EnAr.Element classChild in explorer.GetChildrenElementsWithType(metamodelPackage, "class"))
{
EMOF.IType type = ConstructType(classChild);
package.OwnedType.Add(type);
type.Package = package;
}
// We create its nested Packages
foreach (EnAr.Package metamodelChild in explorer.GetChildrenPackages(metamodelPackage))
{
EMOF.IPackage nestedPackage = ConstructPackage(metamodelChild);
package.NestedPackage.Add(nestedPackage);
nestedPackage.NestingPackage = package;
}
return(package);
}
}
private EnAr.Package ConstructMetamodelPackage(Ecore.IEPackage ePackage, bool constructContent = false)
{
if (!ePackage2Package.ContainsKey(ePackage))
{
EnAr.Package parentPackage = ePackage.ESuperPackage != null
? ConstructMetamodelPackage(ePackage.ESuperPackage)
: rootContainerPackage;
EnAr.Package package = (EnAr.Package)parentPackage.Packages.AddNew(ePackage.Name, "Package");
ePackage2Package[ePackage] = package;
package.Element.Stereotype = "metamodel";
parentPackage.Packages.Refresh();
parentPackage.Update();
package.Update();
package.Element.Update();
}
if (constructContent)
{
foreach (Ecore.IEClassifier eClassifier in ePackage.EClassifiers)
{
ConstructClassifier(eClassifier);
}
foreach (Ecore.IEPackage eSubpackage in ePackage.ESubpackages)
{
ConstructMetamodelPackage(eSubpackage, true);
}
}
return(ePackage2Package[ePackage]);
}
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);
}
internal void Enforce(ISet <CheckResultAddStructureRoot> result, LL.MDE.DataModels.XML.Tag structureElements)
{
foreach (CheckResultAddStructureRoot match in result)
{
// Extracting variables binded in source domains
LL.MDE.DataModels.EnAr.Package abstractionLevelP = match.matchDomainAbstractionLevelP.abstractionLevelP;
string alpName = match.matchDomainAbstractionLevelP.alpName;
LL.MDE.DataModels.EnAr.Package fctsysP = match.matchDomainAbstractionLevelP.fctsysP;
string fctsysName = match.matchDomainAbstractionLevelP.fctsysName;
LL.MDE.DataModels.XML.Tag structure = match.matchDomainStructure.structure;
// Assigning variables binded in the where clause
string elementName = fctsysName + ' ' + alpName;
// Enforcing each enforced domain
MatchDomainStructureElements targetMatchDomainStructureElements = EnforceStructureElements(elementName, structureElements);
// Retrieving variables binded in the enforced domains
LL.MDE.DataModels.XML.Tag fmStructureelement = targetMatchDomainStructureElements.fmStructureelement;
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.Tag fmSeDecomposition = targetMatchDomainStructureElements.fmSeDecomposition;
LL.MDE.DataModels.XML.Attribute structureId = targetMatchDomainStructureElements.structureId;
// Calling other relations as defined in the where clause
new RelationCreateStructureRootLink(editor, transformation).CheckAndEnforce(structureId, structure); new RelationRootProperty2StructureElement(editor, transformation).CheckAndEnforce(abstractionLevelP, fmSeDecomposition, structure, structureElements);
}
}
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);
}
}
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);
}
}
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);
}
internal static ISet <MatchDomainP2> CheckDomainP2(LL.MDE.DataModels.EnAr.Package p2)
{
ISet <MatchDomainP2> result = new HashSet <MatchDomainP2>();
MatchDomainP2 match = new MatchDomainP2()
{
p2 = p2,
};
result.Add(match);
return(result);
}
public List <EnAr.Element> GetChildrenElements(EnAr.Package package)
{
List <EnAr.Element> result = new List <EnAr.Element>();
foreach (object e in package.Elements)
{
if (e is EnAr.Element)
{
result.Add(e as EnAr.Element);
}
}
return(result);
}
public Tuple <EMOF.IPackage, string> ConstructMetamodel(string metamodelName)
{
List <EnAr.Package> metamodelPackages = explorer.FindPackagesWithStereotype("metamodel");
EnAr.Package metamodelPackage = metamodelPackages.Single(p => p.Name == metamodelName);
EMOF.IPackage emofMetamodel = ConstructPackage(metamodelPackage);
string alias = null;
// We store the alias, if any
if (!string.IsNullOrWhiteSpace(metamodelPackage.Alias))
{
alias = metamodelPackage.Alias;
}
return(new Tuple <EMOF.IPackage, string>(emofMetamodel, alias));
}
internal void CheckAndEnforce(LL.MDE.DataModels.EnAr.Package abstractionLevelP, LL.MDE.DataModels.XML.Tag structure, LL.MDE.DataModels.XML.Tag structureElements)
{
CheckOnlyDomains input = new CheckOnlyDomains(abstractionLevelP, structure);
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 <CheckResultAddStructureRoot> result = Check(abstractionLevelP, structure);
Enforce(result, structureElements);
traceabilityMap[input] = output;
}
}
internal void CheckAndEnforce(LL.MDE.DataModels.EnAr.Package productP, LL.MDE.DataModels.XML.Tag fmStructureRefs, LL.MDE.DataModels.XML.Tag fmStructureElements, LL.MDE.DataModels.XML.Tag fmStructures)
{
CheckOnlyDomains input = new CheckOnlyDomains(productP, fmStructureRefs, fmStructureElements);
EnforceDomains output = new EnforceDomains(fmStructures);
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 <CheckResultProduct2Structure> result = Check(productP, fmStructureRefs, fmStructureElements);
Enforce(result, fmStructures);
traceabilityMap[input] = output;
}
}
public void CheckAndEnforce(LL.MDE.DataModels.XML.XMLFile fmeaFile, LL.MDE.DataModels.EnAr.Package alP)
{
CheckOnlyDomains input = new CheckOnlyDomains(alP);
EnforceDomains output = new EnforceDomains(fmeaFile);
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 <CheckResultEA2FMEA_Start> result = Check(alP);
Enforce(result, fmeaFile);
traceabilityMap[input] = output;
}
}
public void CheckAndEnforce(LL.MDE.DataModels.EnAr.Package p, string someString, LL.MDE.DataModels.EnAr.Package p2, LL.MDE.DataModels.EnAr.Package po)
{
CheckOnlyDomains input = new CheckOnlyDomains(p, someString, p2);
EnforceDomains output = new EnforceDomains(po);
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 <CheckResultRelation1> result = Check(p, someString, p2);
Enforce(result, someString, po);
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);
}
internal static ISet <MatchDomainAbstractionLevelP> CheckDomainAbstractionLevelP(LL.MDE.DataModels.EnAr.Package abstractionLevelP)
{
ISet <MatchDomainAbstractionLevelP> result = new HashSet <MatchDomainAbstractionLevelP>();
string alpName = abstractionLevelP.Name;
LL.MDE.DataModels.EnAr.Package fctsysP = abstractionLevelP.ParentPackage();
string fctsysName = fctsysP.Name;
MatchDomainAbstractionLevelP match = new MatchDomainAbstractionLevelP()
{
abstractionLevelP = abstractionLevelP,
alpName = alpName,
fctsysP = fctsysP,
fctsysName = fctsysName,
};
result.Add(match);
return(result);
}
internal static ISet <CheckResultAddStructureRoot> Check(LL.MDE.DataModels.EnAr.Package abstractionLevelP, LL.MDE.DataModels.XML.Tag structure)
{
ISet <CheckResultAddStructureRoot> result = new HashSet <CheckResultAddStructureRoot>(); ISet <MatchDomainAbstractionLevelP> matchDomainAbstractionLevelPs = CheckDomainAbstractionLevelP(abstractionLevelP); ISet <MatchDomainStructure> matchDomainStructures = CheckDomainStructure(structure); foreach (MatchDomainAbstractionLevelP matchDomainAbstractionLevelP in matchDomainAbstractionLevelPs)
{
foreach (MatchDomainStructure matchDomainStructure in matchDomainStructures)
{
string alpName = matchDomainAbstractionLevelP.alpName;
LL.MDE.DataModels.EnAr.Package fctsysP = matchDomainAbstractionLevelP.fctsysP;
string fctsysName = matchDomainAbstractionLevelP.fctsysName;
CheckResultAddStructureRoot checkonlysMatch = new CheckResultAddStructureRoot()
{
matchDomainAbstractionLevelP = matchDomainAbstractionLevelP, matchDomainStructure = matchDomainStructure,
};
result.Add(checkonlysMatch);
} // End foreach
} // End foreach
return(result);
}
internal static ISet <MatchDomainProductP> CheckDomainProductP(LL.MDE.DataModels.EnAr.Package productP)
{
ISet <MatchDomainProductP> result = new HashSet <MatchDomainProductP>();
string productName = productP.Name;
LL.MDE.DataModels.EnAr.Element productPE = productP.Element;
string productID = productPE.ElementGUID;
if (productPE.ElementPackage() == productP)
{
MatchDomainProductP match = new MatchDomainProductP()
{
productP = productP,
productName = productName,
productPE = productPE,
productID = productID,
};
result.Add(match);
}
return(result);
}
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;
}
}
internal static ISet <CheckResultProduct2Structure> Check(LL.MDE.DataModels.EnAr.Package productP, LL.MDE.DataModels.XML.Tag fmStructureRefs, LL.MDE.DataModels.XML.Tag fmStructureElements)
{
ISet <CheckResultProduct2Structure> result = new HashSet <CheckResultProduct2Structure>(); ISet <MatchDomainProductP> matchDomainProductPs = CheckDomainProductP(productP); ISet <MatchDomainFmStructureRefs> matchDomainFmStructureRefss = CheckDomainFmStructureRefs(fmStructureRefs); ISet <MatchDomainFmStructureElements> matchDomainFmStructureElementss = CheckDomainFmStructureElements(fmStructureElements); foreach (MatchDomainProductP matchDomainProductP in matchDomainProductPs)
{
foreach (MatchDomainFmStructureRefs matchDomainFmStructureRefs in matchDomainFmStructureRefss)
{
foreach (MatchDomainFmStructureElements matchDomainFmStructureElements in matchDomainFmStructureElementss)
{
string productName = matchDomainProductP.productName;
LL.MDE.DataModels.EnAr.Element productPE = matchDomainProductP.productPE;
string productID = matchDomainProductP.productID;
CheckResultProduct2Structure checkonlysMatch = new CheckResultProduct2Structure()
{
matchDomainProductP = matchDomainProductP, matchDomainFmStructureRefs = matchDomainFmStructureRefs, matchDomainFmStructureElements = matchDomainFmStructureElements,
};
result.Add(checkonlysMatch);
} // End foreach
} // End foreach
} // End foreach
return(result);
}
public void Relation1(LL.MDE.DataModels.EnAr.Package p, string someString, LL.MDE.DataModels.EnAr.Package p2, LL.MDE.DataModels.EnAr.Package po)
{
new RelationRelation1(editor, this).CheckAndEnforce(p, someString, p2, po);
}
public EMOF.IPackage GetEMOFPackage(EnAr.Package p)
{
return(elementToPackage[p]);
}
public EnforceDomains FindPreviousResult(LL.MDE.DataModels.EnAr.Package p, string someString, LL.MDE.DataModels.EnAr.Package p2)
{
CheckOnlyDomains input = new CheckOnlyDomains(p, someString, p2);
return(traceabilityMap.ContainsKey(input) ? traceabilityMap[input] : null);
}
public void EA2FMEA_Start(LL.MDE.DataModels.XML.XMLFile fmeaFile, LL.MDE.DataModels.EnAr.Package alP)
{
new RelationEA2FMEA_Start(editor, this).CheckAndEnforce(fmeaFile, alP);
}
