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();
}
