/// <summary>
/// Creates a filled MOF and UML instance which can be used for further testing
/// </summary>
/// <param name="mof">Mof instance to be returned</param>
/// <param name="uml">Uml instance to be returned</param>
public static void CreateUmlAndMofInstance(out _MOF mof, out _UML uml)
{
var dataLayerLogic = new DataLayerLogic(new DataLayerData());
var dataLayers = new DataLayers();
dataLayers.SetRelationsForDefaultDataLayers(dataLayerLogic);
var strapper = Bootstrapper.PerformFullBootstrap(
new Bootstrapper.FilePaths()
{
PathPrimitive = "Xmi/PrimitiveTypes.xmi",
PathUml = "Xmi/UML.xmi",
PathMof = "Xmi/MOF.xmi"
},
dataLayerLogic,
dataLayers.Mof);
Assert.That(strapper, Is.Not.Null);
Assert.That(strapper.UmlInfrastructure, Is.Not.Null);
Assert.That(
AllDescendentsQuery.getDescendents(strapper.UmlInfrastructure).Count(),
Is.GreaterThan(500));
// Check, if the filled classes are working
mof = dataLayerLogic.Get<_MOF>(dataLayers.Mof);
uml = dataLayerLogic.Get<_UML>(dataLayers.Mof);
Assert.That(mof, Is.Not.Null);
Assert.That(uml, Is.Not.Null);
}
/// <summary>
/// Converts a uml method to a DmML method by moving the supported content
/// </summary>
/// <param name="uml">Uml to be used</param>
/// <param name="dmMl">DmML to be used</param>
public static void Convert(_UML uml, DmML dmMl)
{
// Sets the classes
dmMl.__NamedElement = uml.CommonStructure.__NamedElement;
dmMl.__Class = uml.StructuredClassifiers.__Class;
dmMl.__Property = uml.Classification.__Property;
// Sets the attributes
dmMl.NamedElement.Name = _UML._CommonStructure._NamedElement.name;
dmMl.Class.Attribute = _UML._Classification._Classifier.attribute;
}
private static void TestFillTree()
{
var watch = new Stopwatch();
watch.Start();
var factory = new MofFactory();
var mofExtent = new MofUriExtent("datenmeister:///mof");
var umlExtent = new MofUriExtent("datenmeister:///uml");
var loader = new SimpleLoader(factory);
loader.Load(mofExtent, "data/MOF.xmi");
loader.Load(mofExtent, "data/UML.xmi");
var mof = new _MOF();
var uml = new _UML();
FillTheMOF.DoFill(mofExtent.elements(), mof);
FillTheUML.DoFill(umlExtent.elements(), uml);
watch.Stop();
System.Console.WriteLine($"Elapsed Time for MOF and UML Fill {watch.ElapsedMilliseconds.ToString("n0")} ms");
}
public static void GenerateSourceFor(SourceGeneratorOptions options)
{
var uml = new _UML();
var extent = new MofUriExtent("dm:///sourcegenerator");
var factory = new MofFactory();
// Creates the dotnet types to real MOF Types
var dotNetProvider = new DotNetTypeGenerator(factory, uml);
var package = factory.create(uml.Packages.__Package);
package.set("name", options.Name);
// Do the conversion
var elements = new List<IElement>();
foreach (var type in options.Types)
{
var typeObject = dotNetProvider.CreateTypeFor(type);
elements.Add(typeObject);
}
package.set(_UML._Packages._Package.packagedElement, elements);
// Adds the package
extent.elements().add(package);
var sourceParser = new ElementSourceParser(uml);
// Creates the class tree
var classTreeGenerator = new ClassTreeGenerator(sourceParser)
{
Namespace = options.Namespace
};
classTreeGenerator.Walk(extent);
var sourceClass = classTreeGenerator.Result.ToString();
var pathOfClassTree =
Path.ChangeExtension(
Path.Combine(
options.Path,
options.Name),
".class.cs");
File.WriteAllText(pathOfClassTree, sourceClass);
// Creates now the filler
var fillerGenerator = new FillClassTreeByExtentCreator(options.Name + "Filler", sourceParser)
{
Namespace = options.Namespace,
ClassNameOfTree = classTreeGenerator.UsedClassName
};
fillerGenerator.Walk(extent);
var sourceFiller = fillerGenerator.Result.ToString();
var pathOfFillerTree =
Path.ChangeExtension(
Path.Combine(
options.Path,
options.Name),
".filler.cs");
File.WriteAllText(pathOfFillerTree, sourceFiller);
}
public ElementSourceParser(_UML uml)
{
_uml = uml;
}
