public void TestProxyForUriExtent() { var uriExtent = new MofUriExtent("dm:///test"); var proxiedUriExtent = new ProxyUriExtent(uriExtent).ActivateObjectConversion(); var mofElement = new MofElement(); var otherMofElement = new MofElement(); proxiedUriExtent.elements().add(mofElement); proxiedUriExtent.elements().add(otherMofElement); var returned = proxiedUriExtent.elements().ElementAt(0); Assert.That(returned, Is.TypeOf<ProxyMofElement>()); var proxiedElement = returned as ProxyMofElement; Assert.That(proxiedElement, Is.Not.Null); Assert.That(proxiedElement.GetProxiedElement(), Is.TypeOf<MofElement>()); Assert.That(proxiedUriExtent.elements().remove(proxiedElement), Is.True); Assert.That(proxiedUriExtent.elements().size, Is.EqualTo(1)); proxiedUriExtent.elements().clear(); // Check, if the dereferencing of ProxyMofElements are working proxiedUriExtent.elements().add(proxiedElement); returned = proxiedUriExtent.elements().ElementAt(0); Assert.That(returned, Is.TypeOf<ProxyMofElement>()); proxiedElement = returned as ProxyMofElement; Assert.That(proxiedElement.GetProxiedElement(), Is.TypeOf<MofElement>()); }
public void TestSimpleAutoColumn() { var property1 = "zip"; var property2 = "location"; var mofObject = new MofObject(); mofObject.set(property1, "55130"); mofObject.set(property2, "Mainz"); var mofObject2 = new MofObject(); mofObject2.set(property1, "65474"); mofObject2.set(property2, "Bischofsheim"); var extent = new MofUriExtent("datenmeister:///test"); extent.elements().add(mofObject); extent.elements().add(mofObject2); var creator = new ColumnCreator(null, null, null); var result = creator.FindColumnsForTable(extent); Assert.That(result, Is.Not.Null); Assert.That(result.Columns.Count(), Is.EqualTo(2)); var firstColumn = result.Columns.FirstOrDefault(x => x.name == "zip"); var secondColumn = result.Columns.FirstOrDefault(x => x.name == "location"); Assert.That(firstColumn, Is.Not.Null); Assert.That(secondColumn, Is.Not.Null); Assert.That(firstColumn.isEnumeration, Is.False); Assert.That(result.Properties.Count, Is.EqualTo(2)); Assert.That(result.Properties[0], Is.EqualTo("zip")); Assert.That(result.Properties[1], Is.EqualTo("location")); }
public void LoadZipCodes(Stream stream) { var csvSettings = new CSVSettings { Encoding = "UTF-8", Separator = '\t', HasHeader = false }; ZipCodes = new MofUriExtent("datenmeister:///zipcodes"); var factory = new MofFactory(); var csvProvider = new CSVDataProvider(null, null); csvProvider.Load( ZipCodes, factory, stream, csvSettings); Columns.ZipCode = csvSettings.Columns[1]; Columns.Name = csvSettings.Columns[4]; Debug.WriteLine($"Loaded: {ZipCodes.elements().Count()} Zipcodes"); }
public void TestMultiplePropertyFilter() { var properties = new[] { property1, property2 }; var mofObject = new MofObject(); mofObject.set(property1, "55130"); mofObject.set(property2, "Mainz"); var mofObject2 = new MofObject(); mofObject2.set(property1, "65474"); mofObject2.set(property2, "Bischofsheim"); var mofObject3 = new MofObject(); var mofExtent = new MofUriExtent("datenmeister:///"); Assert.That(mofExtent.elements().add(mofObject), Is.True); Assert.That(mofExtent.elements().add(mofObject2), Is.True); Assert.That(mofExtent.elements().add(mofObject3), Is.True); var result = Filter.WhenOneOfThePropertyContains( mofExtent.elements(), properties, "Mai"); Assert.That(result.size(), Is.EqualTo(1)); Assert.That(result.ElementAt(0), Is.EqualTo(mofObject)); result = Filter.WhenOneOfThePropertyContains( mofExtent.elements(), properties, "55130"); Assert.That(result.size(), Is.EqualTo(1)); Assert.That(result.ElementAt(0), Is.EqualTo(mofObject)); result = Filter.WhenOneOfThePropertyContains( mofExtent.elements(), properties, "Bisch"); Assert.That(result.size(), Is.EqualTo(1)); Assert.That(result.ElementAt(0), Is.EqualTo(mofObject2)); result = Filter.WhenOneOfThePropertyContains( mofExtent.elements(), properties, "xyz"); Assert.That(result.size(), Is.EqualTo(0)); result = Filter.WhenOneOfThePropertyContains( mofExtent.elements(), properties, "i"); Assert.That(result.size(), Is.EqualTo(2)); Assert.That(result.Contains(mofObject), Is.True); Assert.That(result.Contains(mofObject2), Is.True); }
public void LoadUmlInfrastructure() { var factory = new MofFactory(); var extent = new MofUriExtent("datenmeister:///target"); Assert.That(extent.elements().Count(), Is.EqualTo(0)); var loader = new SimpleLoader(factory); loader.Load(extent, "Xmi/UML.xmi"); var firstElement = (extent.elements().ElementAt(0) as IObject); Assert.That(firstElement, Is.Not.Null); Assert.That(firstElement.get("name").ToString(), Is.EqualTo("UML")); }
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 IUriExtent LoadExtent(ExtentStorageConfiguration configuration, bool createAlsoEmpty) { var csvConfiguration = (CSVStorageConfiguration) configuration; var provider = new CSVDataProvider(_workspaceCollection, _dataLayerLogic); var mofExtent = new MofUriExtent(csvConfiguration.ExtentUri); var factory = new MofFactory(); var doesFileExist = File.Exists(csvConfiguration.Path); if (doesFileExist) { provider.Load(mofExtent, factory, csvConfiguration.Path, csvConfiguration.Settings); } else if (!createAlsoEmpty) { throw new InvalidOperationException( $"File does not exist and empty extents is not given in argument {nameof(createAlsoEmpty)}"); } return mofExtent; }
public void TestFactoryMappingByAttributeForFactories() { var kernel = new ContainerBuilder(); kernel.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource()); var builder = kernel.Build(); using (var scope = builder.BeginLifetimeScope()) { var mapper = new DefaultFactoryMapper(); mapper.PerformAutomaticMappingByAttribute(); Assert.That(mapper.HasMappingForExtentType(typeof(MofUriExtent)), Is.True); Assert.That(mapper.HasMappingForExtentType(typeof(MofElement)), Is.False); Assert.That(mapper.FindFactoryFor(scope, typeof(MofUriExtent)), Is.TypeOf<MofFactory>()); var uriExtent = new MofUriExtent("dm:///localhost"); Assert.That(mapper.FindFactoryFor(scope, uriExtent), Is.TypeOf<MofFactory>()); } }
public void TestCreatabeTypes() { var kernel = new ContainerBuilder(); var builder = kernel.UseDatenMeisterDotNet(new IntegrationSettings {PathToXmiFiles = "Xmi"}); using (var scope = builder.BeginLifetimeScope()) { // Apply for zipcodes var integrateZipCodes = scope.Resolve<Integrate>(); integrateZipCodes.Into(scope.Resolve<IWorkspaceCollection>().FindExtent("dm:///types")); var extentFunctions = scope.Resolve<ExtentFunctions>(); var dataLayers = scope.Resolve<DataLayers>(); var dataExtent = new MofUriExtent("dm:///test"); var creatableTypes = extentFunctions.GetCreatableTypes(dataExtent); Assert.That(creatableTypes, Is.Not.Null); Assert.That(creatableTypes.MetaLayer, Is.EqualTo(dataLayers.Types)); Assert.That(creatableTypes.CreatableTypes.Count, Is.EqualTo(1)); } }
public void TestKnowsExtent() { var uriExtent = new MofUriExtent("dm:///test"); var mofElement = new MofElement(); var otherMofElement = new MofElement(); Assert.That(((IObjectKnowsExtent)mofElement).Extents.FirstOrDefault(), Is.Null); Assert.That(((IObjectKnowsExtent)otherMofElement).Extents.FirstOrDefault(), Is.Null); uriExtent.elements().add(mofElement); Assert.That(((IObjectKnowsExtent)mofElement).Extents.First(), Is.SameAs(uriExtent)); Assert.That(((IObjectKnowsExtent)otherMofElement).Extents.FirstOrDefault(), Is.Null); uriExtent.elements().add(otherMofElement); Assert.That(((IObjectKnowsExtent)mofElement).Extents.First(), Is.SameAs(uriExtent)); Assert.That(((IObjectKnowsExtent)otherMofElement).Extents.First(), Is.SameAs(uriExtent)); }
public void TestFindByUri() { var workspace = new Workspace<IExtent>("data", "No annotation"); var extent = new MofUriExtent("http://test/"); var factory = new MofFactory(); var element = factory.create(null); extent.elements().add(element); workspace.AddExtent(extent); var elementAsMofElement = (MofElement) element; var guid = elementAsMofElement.Id; // Now check, if everything is working var found = extent.element("http://test/#" + guid); Assert.That(found, Is.EqualTo(element)); var anotherFound = workspace.FindElementByUri("http://test/#" + guid); Assert.That(anotherFound, Is.EqualTo(element)); }
public void TestDataLayersForItem() { var dataLayers = new DataLayers(); var data = new DataLayerData(dataLayers); IDataLayerLogic logic = new DataLayerLogic(data); dataLayers.SetRelationsForDefaultDataLayers(logic); var dataExtent = new MofUriExtent("Data"); var umlExtent = new MofUriExtent("Uml"); logic.AssignToDataLayer(dataExtent, dataLayers.Data); logic.AssignToDataLayer(umlExtent, dataLayers.Uml); var value = new MofElement(null, null); var logicLayer = logic.GetDataLayerOfObject(value); Assert.That(logicLayer, Is.SameAs(dataLayers.Data)); // Per Default, only the Data umlExtent.elements().add(value); logicLayer = logic.GetDataLayerOfObject(value); Assert.That(logicLayer, Is.SameAs(dataLayers.Uml)); }
public void TestDataLayers() { var dataLayers = new DataLayers(); var data = new DataLayerData(dataLayers); IDataLayerLogic logic = new DataLayerLogic(data); dataLayers.SetRelationsForDefaultDataLayers(logic); var dataExtent = new MofUriExtent("Data"); var typeExtent = new MofUriExtent("Types"); var umlExtent = new MofUriExtent("Uml"); var unAssignedExtent = new MofUriExtent("Unassigned"); logic.AssignToDataLayer(dataExtent, dataLayers.Data); logic.AssignToDataLayer(typeExtent, dataLayers.Types); logic.AssignToDataLayer(umlExtent, dataLayers.Uml); Assert.That(logic.GetDataLayerOfExtent(dataExtent), Is.EqualTo(dataLayers.Data)); Assert.That(logic.GetDataLayerOfExtent(typeExtent), Is.EqualTo(dataLayers.Types)); Assert.That(logic.GetDataLayerOfExtent(umlExtent), Is.EqualTo(dataLayers.Uml)); Assert.That(logic.GetDataLayerOfExtent(unAssignedExtent), Is.EqualTo(dataLayers.Data)); Assert.That(logic.GetMetaLayerFor(dataLayers.Data), Is.EqualTo(dataLayers.Types)); }
public void TestEnumerationAutoColumn() { var property1 = "zip"; var property2 = "location"; var property3 = "other"; var mofObject = new MofObject(); mofObject.set(property1, "55130"); mofObject.set(property2, "Mainz"); var mofObject2 = new MofObject(); mofObject2.set(property1, "65474"); mofObject2.set(property2, "Bischofsheim"); var enumeration = new MofReflectiveSequence(); enumeration.add(new MofObject()); mofObject2.set(property3, enumeration); var extent = new MofUriExtent("datenmeister:///test"); extent.elements().add(mofObject); extent.elements().add(mofObject2); // Execute the stuff var creator = new ColumnCreator(null, null, null); var result = creator.FindColumnsForTable(extent); Assert.That(result, Is.Not.Null); Assert.That(result.Columns.Count(), Is.EqualTo(3)); var firstColumn = result.Columns.FirstOrDefault(x => x.name == "zip"); var secondColumn = result.Columns.FirstOrDefault(x => x.name == "location"); var thirdColumn = result.Columns.FirstOrDefault(x => x.name == "other"); Assert.That(firstColumn, Is.Not.Null); Assert.That(secondColumn, Is.Not.Null); Assert.That(firstColumn.isEnumeration, Is.False); Assert.That(secondColumn.isEnumeration, Is.False); Assert.That(thirdColumn.isEnumeration, Is.True); }
public void TestStoreAndFindObject() { var mofElement = new MofElement(); var otherMofElement = new MofElement(); var mofInstance = new MofUriExtent("datenmeister:///test"); mofInstance.elements().add(mofElement); mofInstance.elements().add(otherMofElement); // Gets the uris var uri1 = mofInstance.uri(mofElement); var uri2 = mofInstance.uri(otherMofElement); Assert.That(uri1, Is.Not.Null); // Gets the instances var found1 = mofInstance.element(uri1); var found2 = mofInstance.element(uri2); Assert.That(found1, Is.Not.Null); Assert.That(found2, Is.Not.Null); Assert.That(found1, Is.SameAs(mofElement)); Assert.That(found2, Is.SameAs(otherMofElement)); }
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 IContainer UseDatenMeister(ContainerBuilder kernel) { if (_settings == null) { Debug.WriteLine("No integration settings were given. Loading the default values."); _settings = new IntegrationSettings(); } kernel.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource()); var watch = new Stopwatch(); watch.Start(); // Defines the factory method for a certain extent type var factoryMapper = new DefaultFactoryMapper(); kernel.RegisterInstance(factoryMapper).As<IFactoryMapper>(); // Finds the loader for a certain extent type var storageMap = new ManualConfigurationToExtentStorageMapper(); kernel.RegisterInstance(storageMap).As<IConfigurationToExtentStorageMapper>(); // Workspace collection var workspaceCollection = new WorkspaceCollection(); workspaceCollection.Init(); kernel.RegisterInstance(workspaceCollection).As<IWorkspaceCollection>(); // Defines the extent storage data var extentStorageData = new ExtentStorageData(); kernel.RegisterInstance(extentStorageData).As<ExtentStorageData>(); kernel.RegisterType<ExtentStorageLoader>().As<IExtentStorageLoader>(); // Defines the datalayers var dataLayers = new DataLayers(); kernel.RegisterInstance(dataLayers).As<DataLayers>(); var dataLayerData = new DataLayerData(dataLayers); kernel.RegisterInstance(dataLayerData).As<DataLayerData>(); kernel.RegisterType<DataLayerLogic>().As<IDataLayerLogic>(); // Adds the name resolution kernel.RegisterType<UmlNameResolution>().As<IUmlNameResolution>(); var builder = kernel.Build(); using (var scope = builder.BeginLifetimeScope()) { // Is used by .Net Provider to include the mappings for extent storages and factory types _settings?.Hooks?.OnStartScope(scope); var dataLayerLogic = scope.Resolve<IDataLayerLogic>(); dataLayers.SetRelationsForDefaultDataLayers(dataLayerLogic); // Load the default extents // Performs the bootstrap var paths = new Bootstrapper.FilePaths() { PathPrimitive = Path.Combine(_settings.PathToXmiFiles, "PrimitiveTypes.xmi"), PathUml = Path.Combine(_settings.PathToXmiFiles, "UML.xmi"), PathMof = Path.Combine(_settings.PathToXmiFiles, "MOF.xmi") }; if (_settings.PerformSlimIntegration) { throw new InvalidOperationException("Slim integration is currently not supported"); } else { Bootstrapper.PerformFullBootstrap( paths, workspaceCollection.GetWorkspace("UML"), dataLayerLogic, dataLayers.Uml); Bootstrapper.PerformFullBootstrap( paths, workspaceCollection.GetWorkspace("MOF"), dataLayerLogic, dataLayers.Mof); } // Creates the workspace and extent for the types layer which are belonging to the types var extentTypes = new MofUriExtent("dm:///types"); var typeWorkspace = workspaceCollection.GetWorkspace("Types"); typeWorkspace.AddExtent(extentTypes); dataLayerLogic.AssignToDataLayer(extentTypes, dataLayers.Types); // Boots up the typical DatenMeister Environment if (_settings.EstablishDataEnvironment) { EstablishDataEnvironment(builder, scope); } } watch.Stop(); Debug.WriteLine($"Elapsed time for bootstrap: {watch.Elapsed}"); return builder; }
public static void Main(string[] args) { var factory = new MofFactory(); var umlExtent = new MofUriExtent("datenmeister:///uml"); var mofExtent = new MofUriExtent("datenmeister:///mof"); var primitiveTypeExtent = new MofUriExtent("datenmeister:///primitivetypes"); var loader = new SimpleLoader(factory); loader.Load(umlExtent, "data/UML.xmi"); loader.Load(mofExtent, "data/MOF.xmi"); loader.Load(primitiveTypeExtent, "data/PrimitiveTypes.xmi"); // Generates tree for UML var generator = new ClassTreeGenerator { Namespace = "DatenMeister" }; generator.Walk(umlExtent); var extentCreator = new FillClassTreeByExtentCreator("DatenMeister._UML") { Namespace = "DatenMeister.Filler" }; extentCreator.Walk(umlExtent); File.WriteAllText("../../uml.cs", generator.Result.ToString()); File.WriteAllText("../../FillTheUML.cs", extentCreator.Result.ToString()); Console.WriteLine("C# Code for UML written"); // Generates tree for MOF generator = new ClassTreeGenerator { Namespace = "DatenMeister" }; generator.Walk(mofExtent); extentCreator = new FillClassTreeByExtentCreator("DatenMeister._MOF") { Namespace = "DatenMeister.Filler" }; extentCreator.Walk(mofExtent); File.WriteAllText("../../mof.cs", generator.Result.ToString()); File.WriteAllText("../../FillTheMOF.cs", extentCreator.Result.ToString()); Console.WriteLine("C# Code for MOF written"); // Generates tree for PrimitiveTypes generator = new ClassTreeGenerator { Namespace = "DatenMeister" }; generator.Walk(primitiveTypeExtent); extentCreator = new FillClassTreeByExtentCreator("DatenMeister._PrimitiveTypes") { Namespace = "DatenMeister.Filler" }; extentCreator.Walk(primitiveTypeExtent); File.WriteAllText("../../primitivetypes.cs", generator.Result.ToString()); File.WriteAllText("../../FillThePrimitiveTypes.cs", extentCreator.Result.ToString()); Console.WriteLine("C# Code for PrimitiveTypes written"); #if !DEBUG File.Copy("../../primitivetypes.cs", "../../../DatenMeister/Filler/primitivetypes.cs", true); File.Copy("../../FillThePrimitiveTypes.cs", "../../../DatenMeister/Filler/FillThePrimitiveTypes.cs", true); File.Copy("../../mof.cs", "../../../DatenMeister/Filler/mof.cs", true); File.Copy("../../FillTheMOF.cs", "../../../DatenMeister/Filler/FillTheMOF.cs", true); File.Copy("../../uml.cs", "../../../DatenMeister/Filler/uml.cs", true); File.Copy("../../FillTheUML.cs", "../../../DatenMeister/Filler/FillTheUML.cs", true); #endif }
/// <summary> /// Performs a full bootstrap by reading in the uml class /// </summary> /// <param name="paths">Paths storing the uml information</param> /// <param name="dataLayerLogic">The datalayer logic to be used</param> /// <param name="dataLayer">The datalayer to be filled before the bootstrap itself</param> /// <returns>The instance of the bootstrapper</returns> public static Bootstrapper PerformFullBootstrap( FilePaths paths, IDataLayerLogic dataLayerLogic, IDataLayer dataLayer) { var factory = new MofFactory(); var umlExtent = new MofUriExtent("datenmeister:///uml"); var mofExtent = new MofUriExtent("datenmeister:///mof"); var primitiveExtent = new MofUriExtent("datenmeister:///prototypes"); var loader = new SimpleLoader(factory); loader.Load(primitiveExtent, paths.PathPrimitive); loader.Load(umlExtent, paths.PathUml); loader.Load(mofExtent, paths.PathMof); // Assigns the extents to the datalayer if (dataLayer != null && dataLayerLogic != null) { dataLayerLogic.AssignToDataLayer(mofExtent, dataLayer); dataLayerLogic.AssignToDataLayer(umlExtent, dataLayer); dataLayerLogic.AssignToDataLayer(primitiveExtent, dataLayer); dataLayerLogic.Create<FillTheMOF, _MOF>(dataLayer); dataLayerLogic.Create<FillTheUML, _UML>(dataLayer); dataLayerLogic.Create<FillThePrimitiveTypes, _PrimitiveTypes>(dataLayer); var dmml = new DmML(); UmlToDmMLConverter.Convert(dataLayerLogic.Get<_UML>(dataLayer), dmml); dataLayerLogic.Set(dataLayer, dmml); } else { // To support the creation of _MOF and _UML, we need to have datalayers and their logic throw new InvalidOperationException("datalayers or dataLayerLogic is null"); } // Now do the bootstrap var bootStrapper = new Bootstrapper(primitiveExtent, umlExtent, mofExtent, dataLayerLogic); bootStrapper.Strap(); return bootStrapper; }
public MofExtentReflectiveSequence(MofUriExtent extent, List<object> values) : base(values) { Debug.Assert(extent != null, "extent != null"); _extent = extent; }
private static void TestZipCodes() { // Checks the loading of the PLZ System.Console.WriteLine("Loading the Zip codes"); var extent = new MofUriExtent("mof:///plz"); var factory = new MofFactory(); var csvSettings = new CSVSettings { Encoding = "ISO-8859-1", Separator = '\t', HasHeader = false }; var provider = new CSVDataProvider(null, null); provider.Load(extent, factory, "data/plz.csv", csvSettings); System.Console.WriteLine($"Loaded: {extent.elements().Count().ToString()} Zipcodes"); System.Console.WriteLine(); }