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);
}
}
/* public Tuple<EMOF.IPackage,IEnumerable<string>> ConstructMetamodel(string metamodelName)
* {
* List<EnAr.Package> metamodelPackages = explorer.FindPackagesWithStereotype("metamodel");
*
* return null;
* }
*/
public static string GetFQN(EMOF.IPackage package)
{
if (package.NestingPackage == null)
{
return(package.Name);
}
else
{
return(GetFQN(package.NestingPackage) + "." + package.Name);
}
}
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));
}
/// <summary>
/// Find all metamodels of the EA file and import them.
/// </summary>
/// <returns> A Tuple with the metamodels, and the aliases of the metamodel.</returns>
public Tuple <List <EMOF.IPackage>, Dictionary <string, EMOF.IPackage> > ConstructMetamodels()
{
List <EMOF.IPackage> metamodels = new List <EMOF.IPackage>();
Dictionary <string, EMOF.IPackage> aliases = new Dictionary <string, EMOF.IPackage>();
// We browse all package elements with stereotype "metamodel"
List <EnAr.Package> metamodelPackages = explorer.FindPackagesWithStereotype("metamodel");
foreach (EnAr.Package metamodelPackage in metamodelPackages)
{
EMOF.IPackage emofMetamodel = ConstructPackage(metamodelPackage);
// We import into an EMOF Package
metamodels.Add(emofMetamodel);
// We store the alias, if any
if (!string.IsNullOrWhiteSpace(metamodelPackage.Alias))
{
aliases.Add(metamodelPackage.Alias, emofMetamodel);
}
}
return(new Tuple <List <EMOF.IPackage>, Dictionary <string, EMOF.IPackage> >(metamodels, aliases));
}
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);
}
