Add design spec for OpenGL 3D view

Replaces the JavaFX SubScene/MeshView rendering with an OpenGL viewport
(openglfx-jogl, GL 3.3 core), single global VBO, GPU color-picking, and
baked fake shading. Windows/Linux targets; JavaFX 3D path removed.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/CopyHandler.java

-/*-
- *  Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
- * 
- *  This file is part of CityDoctor2.
- *
- *  CityDoctor2 is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  CityDoctor2 is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with CityDoctor2.  If not, see <https://www.gnu.org/licenses/>.
- */
-package de.hft.stuttgart.citydoctor2.utils;
-
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.IdentityHashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-public class CopyHandler {
-	
-	
-	private final Set<Copyable> toBeDoneInstances = new HashSet<>();
-	private final Map<Copyable, Copyable> finishedInstances = new IdentityHashMap<>();
-	
-	@SuppressWarnings("unchecked")
-	public <T extends Copyable> T copy(T original) {
-		toBeDoneInstances.add(original);
-		while (!toBeDoneInstances.isEmpty()) {
-			handleNextInstance();
-		}
-		for (Entry<Copyable, Copyable> e : finishedInstances.entrySet()) {
-			e.getValue().fillValues(e.getKey(), this);
-		}
-		return (T) finishedInstances.get(original);
-	}
-	
-	@SuppressWarnings("unchecked")
-	public <T extends Copyable> T getCopyInstance(T original) {
-		if (original == null) {
-			// null gets copied to null
-			return null;
-		}
-		return (T) finishedInstances.get(original);
-	}
-	
-	public void addInstance(Copyable copyable) {
-		if (copyable == null) {
-			// don't care for null instances
-			return;
-		}
-		if (finishedInstances.containsKey(copyable)) {
-			// already processed
-			return;
-		}
-		toBeDoneInstances.add(copyable);
-	}
-	
-	private void handleNextInstance() {
-		Iterator<Copyable> iterator = toBeDoneInstances.iterator();
-		Copyable next = iterator.next();
-		iterator.remove();
-		finishedInstances.put(next, next.createCopyInstance());
-		next.collectInstances(this);
-	}
-
-	public void addInstance(Collection<? extends Copyable> collection) {
-		if (collection == null) {
-			return;
-		}
-		for (Copyable c : collection) {
-			addInstance(c);
-		}
-	}
-
-
-}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/Copyable.java

-/*-
- *  Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
- * 
- *  This file is part of CityDoctor2.
- *
- *  CityDoctor2 is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  CityDoctor2 is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with CityDoctor2.  If not, see <https://www.gnu.org/licenses/>.
- */
-package de.hft.stuttgart.citydoctor2.utils;
-
-public interface Copyable {
-	
-	public void collectInstances(CopyHandler handler);
-	public Copyable createCopyInstance();
-	public void fillValues(Copyable original, CopyHandler handler); 
-	
-}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/ThrowUtils.java

+package de.hft.stuttgart.citydoctor2.utils;
+
+public class ThrowUtils {
+
+    private ThrowUtils() {
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T extends Throwable> void uncheckThrowable(Throwable t) throws T {
+        throw (T) t;
+    }
+
+    /**
+     * Throws a Throwable as an unchecked generic Throwable
+     */
+    public static void sneakyThrow(Throwable t) {
+        uncheckThrowable(t);
+    }
+
+
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/TimeFormatter.java

+package de.hft.stuttgart.citydoctor2.utils;
+
+import java.text.ChoiceFormat;
+
+public final class TimeFormatter {
+
+    private TimeFormatter(){}
+
+    private static final String LESS_THAN_A_SECOND =
+            Localization.getText("TimeFormatter.lessThanASecond");
+
+    private static final ChoiceFormat SECONDS =
+            new ChoiceFormat(
+                    new double[]{1, 2},
+                    new String[]{Localization.getText("TimeFormatter.oneSecond"),
+                            Localization.getText("TimeFormatter.seconds")}
+            );
+
+    private static final ChoiceFormat MINUTES =
+            new ChoiceFormat(
+                    new double[]{1, 2},
+                    new String[]{Localization.getText("TimeFormatter.oneMinute"),
+                            Localization.getText("TimeFormatter.minutes")}
+            );
+
+    private static final ChoiceFormat HOURS =
+            new ChoiceFormat(
+                    new double[] {1, 2},
+                    new String[]{Localization.getText("TimeFormatter.oneHour"),
+                            Localization.getText("TimeFormatter.hours")}
+            );
+
+    /**
+     * Formats a time measurement in milliseconds as a localized String representation.
+     *
+     * <p>
+     * The String representation will return the time as a rounded down integer of the biggest fitting TimeUnit
+     * (seconds, minutes or hours), returning "< 1 second" for times under a second.
+     * <p/>
+     * @param millis
+     * @return A localized String representation of the timespan
+     */
+    public static String format(long millis) {
+        if (millis < 1000) {
+            return LESS_THAN_A_SECOND;
+        }else if (millis < 60_000) {
+            long seconds = millis / 1000;
+            String pattern = SECONDS.format(seconds);
+            return pattern.replace("{0}", Long.toString(seconds));
+        }else if (millis < 3_600_000){
+            long minutes = millis / 60_000;
+            String pattern = MINUTES.format(minutes);
+            return pattern.replace("{0}", Long.toString(minutes));
+        } else {
+            long hours = millis / 3_600_000;
+            String pattern = HOURS.format(hours);
+            return pattern.replace("{0}", Long.toString(hours));
+        }
+
+
+    }
+}
\ No newline at end of file

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/CheckableErrorCollector.java

+package de.hft.stuttgart.citydoctor2.utils.visitors;
+
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
+import de.hft.stuttgart.citydoctor2.check.CheckError;
+import de.hft.stuttgart.citydoctor2.check.Checkable;
+
+import java.util.List;
+
+/**
+ * This Visitor collects all CheckErrors in the datastructure of a checkable.
+ */
+public class CheckableErrorCollector extends CheckableUtilsVisitor {
+
+    List<CheckError> errors;
+
+    /**
+     * Collects all CheckErrors into a list
+     *
+     * @param errors the list
+     */
+    public CheckableErrorCollector(List<CheckError> errors) {
+        this.errors = errors;
+    }
+
+    @Override
+    public void check(Checkable checkable) {
+        checkable.collectErrors(errors);
+    }
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/CityObjectCollector.java

+package de.hft.stuttgart.citydoctor2.utils.visitors;
+
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
+import de.hft.stuttgart.citydoctor2.datastructure.CityObject;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * This Visitor collects all sub-CityObjects that are in the datastructure of a CityObject (including itself) in a Set.
+ */
+public class CityObjectCollector extends CheckableUtilsVisitor {
+
+    private final Set<CityObject> objects = new HashSet<>();
+
+    /**
+     * Returns the collected CityObjects.
+     *
+     * @return A set of CityObjects
+     */
+    public Set<CityObject> getCityObjects() {
+        return objects;
+    }
+
+    @Override
+    public void check(CityObject co) {
+        objects.add(co);
+    }
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ClearMetaInformationVisitor.java

+package de.hft.stuttgart.citydoctor2.utils.visitors;
+
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
+
+/**
+ * This Visitor removes the metadata created by the {@link PrepareForCheckingVisitor} for the low-memory consumption mode.
+ */
+public class ClearMetaInformationVisitor extends CheckableUtilsVisitor {
+
+    @Override
+    public void check(Geometry geometry) {
+        geometry.clearMetaData();
+    }
+
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ClearResultsVisitor.java

+package de.hft.stuttgart.citydoctor2.utils.visitors;
+
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
+import de.hft.stuttgart.citydoctor2.check.Checkable;
+
+/**
+ * This Visitor removes the check results from a CityObject and the objects in its datastructure.
+ */
+public class ClearResultsVisitor extends CheckableUtilsVisitor {
+
+    @Override
+    public void check(Checkable checkable) {
+        checkable.clearCheckResults();
+    }
+
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ContainsAnyErrorVisitor.java

+package de.hft.stuttgart.citydoctor2.utils.visitors;
+
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
+import de.hft.stuttgart.citydoctor2.check.Checkable;
+import de.hft.stuttgart.citydoctor2.utils.CheckErrorFound;
+import de.hft.stuttgart.citydoctor2.utils.ThrowUtils;
+
+/**
+ * This visitor checks if a checkable contains any error in its datastructure.
+ * <p><p/>
+ * This visitor's check method terminates early by throwing an unchecked {@link CheckErrorFound},
+ * use {@link #checkObject(Checkable) ContainsAnyErrorVisitor.checkObject(Checkable)} to handle the Throwable.
+ */
+public class ContainsAnyErrorVisitor extends CheckableUtilsVisitor {
+
+    /**
+     * Checks if a Checkable, or any Object in its datastructure, contains any error.
+     * <p>
+     * Terminates early upon finding an error by throwing {@link CheckErrorFound}
+     *
+     * @param checkable The object to check
+     * @throws CheckErrorFound when any Error is found
+     */
+    public static void checkObject(Checkable checkable) throws CheckErrorFound {
+        checkable.accept(new ContainsAnyErrorVisitor());
+    }
+
+    @Override
+    public void check(Checkable checkable) {
+        if (checkable.hasAnyError()) {
+            ThrowUtils.sneakyThrow(new CheckErrorFound());
+        }
+    }
+
+
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ContainsErrorVisitor.java

+package de.hft.stuttgart.citydoctor2.utils.visitors;
+
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
+import de.hft.stuttgart.citydoctor2.check.CheckId;
+import de.hft.stuttgart.citydoctor2.check.Checkable;
+import de.hft.stuttgart.citydoctor2.utils.CheckErrorFound;
+import de.hft.stuttgart.citydoctor2.utils.ThrowUtils;
+
+/**
+ * This visitor checks if a checkable contains a specific error in its datastructure.
+ * <p><p/>
+ * This visitor's check method terminates early by throwing an unchecked {@link CheckErrorFound},
+ * use {@link #checkObject(Checkable, CheckId) ContainsAnyErrorVisitor.checkObject(Checkable, CheckId)} to handle the Throwable.
+ */
+public class ContainsErrorVisitor extends CheckableUtilsVisitor {
+
+    private CheckId checkId;
+
+    /**
+     * Checks if a Checkable, or any Object in its datastructure, contains a specific error.
+     * <p>
+     * Terminates early upon finding the error by throwing {@link CheckErrorFound}
+     *
+     * @param checkable       The object to check
+     * @param checkIdentifier The specific error's associated ID
+     * @throws CheckErrorFound when the error is found
+     */
+    public static void checkObject(Checkable checkable, CheckId checkIdentifier) throws CheckErrorFound {
+        checkable.accept(new ContainsErrorVisitor(checkIdentifier));
+    }
+
+    @Override
+    public void check(Checkable checkable) {
+        if (checkable.hasError(checkId)) {
+            ThrowUtils.sneakyThrow(new CheckErrorFound());
+        }
+    }
+
+    public ContainsErrorVisitor(CheckId checkIdentifier) {
+        super();
+        checkId = checkIdentifier;
+    }
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/GmlGeometryRebuilder.java

+package de.hft.stuttgart.citydoctor2.utils.visitors;
+
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
+import de.hft.stuttgart.citydoctor2.datastructure.CityObject;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+
+import java.util.Objects;
+
+/**
+ * This Visitor recreates the Geometries of the original CityGml object from the associated Geometries in CityDoctor's
+ * internal model.
+ */
+public class GmlGeometryRebuilder extends CheckableUtilsVisitor {
+
+    private final GeometryFactory factory;
+    private final ParserConfiguration config;
+
+    /**
+     * Creates a new Rebuilder for reconstruction of CityGml geometries.
+     *
+     * @param factory       the GeometryFactory used for creation of CityGml geometry objects.
+     * @param configuration the configuration settings of the parser
+     */
+    public GmlGeometryRebuilder(GeometryFactory factory, ParserConfiguration configuration) {
+        Objects.requireNonNull(factory);
+        Objects.requireNonNull(configuration);
+        this.factory = factory;
+        this.config = configuration;
+    }
+
+    @Override
+    public void check(CityObject cityObject) {
+        cityObject.rebuildGeometries(factory, config);
+    }
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/MinMaxExtentVisitor.java

+package de.hft.stuttgart.citydoctor2.utils.visitors;
+
+import de.hft.stuttgart.citydoctor2.check.Checkable;
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
+import de.hft.stuttgart.citydoctor2.datastructure.CityObject;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
+import de.hft.stuttgart.citydoctor2.datastructure.ImplicitGeometryHolder;
+import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
+import de.hft.stuttgart.citydoctor2.math.Vector3d;
+
+public class MinMaxExtentVisitor extends CheckableUtilsVisitor {
+
+    Vector3d low;
+    Vector3d high;
+
+    public MinMaxExtentVisitor() {
+        low = new Vector3d(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
+        high = new Vector3d(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY);
+    }
+
+    public Vector3d[] getMinMaxExtent() {
+        Vector3d[] result = new Vector3d[2];
+        result[0] = low;
+        result[1] = high;
+        return result;
+    }
+
+    @Override
+    public void check(CityObject co) {
+        for (Geometry geom : co.getGeometries()) {
+            if (geom.getVertices() == null) {
+                geom.updateVertices();
+            }
+            for (Vertex v : geom.getVertices()) {
+                if (v.getX() < low.getX()) {
+                    low.setX(v.getX());
+                }
+                if (v.getX() > high.getX()) {
+                    high.setX(v.getX());
+                }
+                if (v.getY() < low.getY()) {
+                    low.setY(v.getY());
+                }
+                if (v.getY() > high.getY()) {
+                    high.setY(v.getY());
+                }
+                if (v.getZ() < low.getZ()) {
+                    low.setZ(v.getZ());
+                }
+                if (v.getZ() > high.getZ()) {
+                    high.setZ(v.getZ());
+                }
+            }
+        }
+    }
+
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/PrepareForCheckingVisitor.java

+package de.hft.stuttgart.citydoctor2.utils.visitors;
+
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
+
+/**
+ * This Visitor prepares the {@link Geometry Geometries} in a Checkable for low-memory consumption mode.
+ */
+public class PrepareForCheckingVisitor extends CheckableUtilsVisitor {
+
+    @Override
+    public void check(Geometry geom) {
+        geom.updateEdgesAndVertices();
+    }
+
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/UnsetGeometriesVisitor.java

+package de.hft.stuttgart.citydoctor2.utils.visitors;
+
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
+import de.hft.stuttgart.citydoctor2.datastructure.CityObject;
+
+/**
+ * This Visitor removes the GmlGeometries from the linked original GmlObjects in a CityObject's datastructure to reduce
+ * memory bloat.
+ */
+public class UnsetGeometriesVisitor extends CheckableUtilsVisitor {
+
+
+    @Override
+    public void check(CityObject cityObject) {
+        cityObject.unsetGmlGeometries();
+    }
+
+
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/writer/CityGMLWriterUtils.java

@@ -22,12 +22,12 @@ import java.io.File;
 import java.time.ZonedDateTime;
 import java.util.HashMap;
 import java.util.Iterator;
-import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Stream;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -65,7 +65,7 @@ public class CityGMLWriterUtils {
 	}
 	
 	public static void writeCityModel(String file, CityDoctorModel model) throws CityDoctorWriteException {
-		CityGMLContext gmlContext = CityGmlParser.getContext();
+		CityGMLContext gmlContext = CityGmlParser.setupContext();
 		CityModel cModel = model.getCityModel();
 		CityGMLOutputFactory factory = gmlContext.createCityGMLOutputFactory(model.getCityGMLVersion());
 		try (CityGMLWriter writer = factory.createCityGMLWriter(new File(file))) {
@@ -92,7 +92,7 @@ public class CityGMLWriterUtils {
 			storeCityObjects(model.getTransportation(), gmlFactory, model, cModel, val);
 			storeCityObjects(model.getWater(), gmlFactory, model, cModel, val);
 			storeCityObjects(model.getCityFurniture(), gmlFactory, model, cModel, val);
-			storeCityObjects(model.getGenericCityObjects(), gmlFactory, model, cModel, val);
+			storeCityObjects(model.getOtherCityObjects(), gmlFactory, model, cModel, val);
 			storeCityObjects(model.getTunnels(), gmlFactory, model, cModel, val);
 
 			writer.write(cModel);
@@ -135,12 +135,13 @@ public class CityGMLWriterUtils {
 			de.hft.stuttgart.quality.model.enums.ErrorId adeId = QualityADEUtils.mapErrorIdToAdeId(e.getKey());
 			if (adeId == null) {
 				// error that is not part of the ade standard
-				logger.warn("Found error {} that cannot be converted to ADE error. It will not be written", e.getKey());
+				logger.warn(Localization.getText("CityGmlWriterUtils.unknownADEError"), e.getKey());
 				continue;
 			}
 			stats.setName(adeId);
 			statistics.getErrors().add(new ErrorProperty(stats));
 		}
+		// TODO: Quality ADE update to CityGML 3.0
 		statistics.setNumErrorBuildings(new FeatureStatisticsProperty(countValidatedCityObjects(model.getBuildings())));
 		statistics.setNumErrorBridgeObjects(new FeatureStatisticsProperty(countValidatedCityObjects(model.getBridges())));
 		statistics.setNumErrorLandObjects(new FeatureStatisticsProperty(countValidatedCityObjects(model.getLand())));
@@ -152,29 +153,30 @@ public class CityGMLWriterUtils {
 		return val;
 	}
 	
-	private static FeatureStatistics countValidatedCityObjects(List<? extends CityObject> cos) {
-		int numChecked = 0;
-		int numError = 0;
-		for (CityObject co : cos) {
+	private static FeatureStatistics countValidatedCityObjects(Stream<? extends CityObject> cos) {
+		AtomicInteger numChecked = new AtomicInteger();
+		AtomicInteger numError = new AtomicInteger();
+		cos.forEach(co -> {
 			if (co.isValidated()) {
-				numChecked++;
+				numChecked.getAndIncrement();
 				if (co.containsAnyError()) {
-					numError++;
+					numError.getAndIncrement();
 				}
 			}
-		}
-		return new FeatureStatistics(numChecked, numError);
+		});
+		return new FeatureStatistics(numChecked.get(), numError.get());
 	}
 	
-	private static void storeCityObjects(List<? extends CityObject> cos, GeometryFactory gmlFactory, CityDoctorModel model, CityModel cModel, Validation val) {
-		for (CityObject co : cos) {
+	private static void storeCityObjects(Stream<? extends CityObject> cos, GeometryFactory gmlFactory, CityDoctorModel model, CityModel cModel, Validation val) {
+		cos.forEach(co -> {
 			if (model.isValidated() && val != null) {
 				QualityADEUtils.writeQualityAde(co, val);
 			}
 
 			co.reCreateGeometries(gmlFactory, model.getParserConfig());
 			cModel.getCityObjectMembers().add(new AbstractCityObjectProperty(co.getGmlObject()));
-		}
+		});
+
 	}
 
 }

CityDoctorParent/CityDoctorModel/src/main/java/org/xmlobjects/xml/Attributes.java

+package org.xmlobjects.xml;
+
+import java.io.Serializable;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.xml.XMLConstants;
+import javax.xml.namespace.QName;
+
+public class Attributes implements Serializable {
+	
+	private static final long serialVersionUID = 8942583366234714632L;
+	
+	private final Map<String, Map<String, TextContent>> attributes = new HashMap<>();
+
+    public boolean isEmpty() {
+        return attributes.isEmpty();
+    }
+
+    public void add(String namespaceURI, String localName, TextContent value) {
+        attributes.computeIfAbsent(namespaceURI, v -> new HashMap<>()).put(localName, value);
+    }
+
+    public void add(String namespaceURI, String localName, String value) {
+        add(namespaceURI, localName, TextContent.of(value));
+    }
+
+    public void add(String localName, TextContent value) {
+        add(XMLConstants.NULL_NS_URI, localName, value);
+    }
+
+    public void add(String localName, String value) {
+        add(localName, TextContent.of(value));
+    }
+
+    public void add(QName name, TextContent value) {
+        add(name.getNamespaceURI(), name.getLocalPart(), value);
+    }
+
+    public void add(QName name, String value) {
+        add(name, TextContent.of(value));
+    }
+
+    public void addAll(String namespaceURI, Map<String, TextContent> attributes) {
+        this.attributes.computeIfAbsent(namespaceURI, v -> new HashMap<>()).putAll(attributes);
+    }
+
+    public Map<String, Map<String, TextContent>> get() {
+        return attributes;
+    }
+
+    public Map<String, TextContent> get(String namespaceURI) {
+        return attributes.getOrDefault(namespaceURI, Collections.emptyMap());
+    }
+
+    public TextContent getValue(String localName) {
+        return getValue(XMLConstants.NULL_NS_URI, localName);
+    }
+
+    public TextContent getValue(String namespaceURI, String localName) {
+        return get(namespaceURI).getOrDefault(localName, TextContent.empty());
+    }
+
+    public TextContent getValue(QName name) {
+        return getValue(name.getNamespaceURI(), name.getLocalPart());
+    }
+
+    public Attributes copy() {
+        Attributes copy = new Attributes();
+        copy.attributes.putAll(attributes);
+        return copy;
+    }
+}

CityDoctorParent/CityDoctorModel/src/main/java/org/xmlobjects/xml/TextContent.java

+package org.xmlobjects.xml;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.time.ZoneOffset;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeConstants;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.Duration;
+import javax.xml.datatype.XMLGregorianCalendar;
+
+public class TextContent implements Serializable {
+	
+	private static final long serialVersionUID = -3862132079185243841L;
+	private static final DatatypeFactory XML_TYPE_FACTORY;
+    private static final TextContent EMPTY = new TextContent("");
+
+    private static Function<LocalDateTime, ZoneOffset> ZONE_OFFSET_PROVIDER = dateTime -> ZoneOffset.systemDefault().getRules().getOffset(dateTime);
+    private static boolean WITH_TIME_OFFSET = true;
+    private static boolean WITH_DATE_OFFSET = false;
+
+    private enum Fields { YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, NANO, TIMEZONE }
+    private static final EnumSet<Fields> DATE_TIME_FIELDS = EnumSet.allOf(Fields.class);
+    private static final EnumSet<Fields> TIME_FIELDS = EnumSet.of(Fields.HOUR, Fields.MINUTE, Fields.SECOND, Fields.NANO, Fields.TIMEZONE);
+    private static final EnumSet<Fields> DATE_FIELDS = EnumSet.of(Fields.YEAR, Fields.MONTH, Fields.DAY, Fields.TIMEZONE);
+    private static final EnumSet<Fields> GYEAR_MONTH_FIELDS = EnumSet.of(Fields.YEAR, Fields.MONTH, Fields.TIMEZONE);
+    private static final EnumSet<Fields> GMONTH_DAY_FIELDS = EnumSet.of(Fields.MONTH, Fields.DAY, Fields.TIMEZONE);
+    private static final EnumSet<Fields> GDAY_FIELDS = EnumSet.of(Fields.DAY, Fields.TIMEZONE);
+    private static final EnumSet<Fields> GMONTH_FIELDS = EnumSet.of(Fields.MONTH, Fields.TIMEZONE);
+    private static final EnumSet<Fields> GYEAR_FIELDS = EnumSet.of(Fields.YEAR, Fields.TIMEZONE);
+
+    static {
+        try {
+            XML_TYPE_FACTORY = DatatypeFactory.newInstance();
+        } catch (DatatypeConfigurationException e) {
+            throw new RuntimeException("Failed to initialize datatype factory.", e);
+        }
+    }
+
+    private String content;
+    private String trimmedContent;
+    private String[] tokenizedContent;
+    private Object value;
+
+    private transient Function<LocalDateTime, ZoneOffset> zoneOffsetProvider = ZONE_OFFSET_PROVIDER;
+
+    private TextContent(String content) {
+        this.content = Objects.requireNonNull(content, "Content must not be null.");
+    }
+
+    public static TextContent empty() {
+        return EMPTY;
+    }
+
+    public static TextContent of(String content) {
+        return ofObject(content);
+    }
+
+    public static TextContent ofList(List<String> content) {
+        return ofObjectList(content);
+    }
+
+    public static TextContent ofBoolean(Boolean content) {
+        return ofObject(content);
+    }
+
+    public static TextContent ofBooleanList(List<Boolean> content) {
+        return ofObjectList(content);
+    }
+
+    public static TextContent ofDouble(Double content) {
+        return ofObject(content);
+    }
+
+    public static TextContent ofDoubleList(List<Double> content) {
+        return ofObjectList(content);
+    }
+
+    public static TextContent ofInteger(Integer content) {
+        return ofObject(content);
+    }
+
+    public static TextContent ofIntegerList(List<Integer> content) {
+        return ofObjectList(content);
+    }
+
+    public static TextContent ofDuration(Duration content) {
+        return ofObject(content);
+    }
+
+    public static TextContent ofDurationList(List<Duration> content) {
+        return ofObjectList(content);
+    }
+
+    public static TextContent ofDateTime(OffsetDateTime content, boolean withOffset) {
+        return ofOffsetDateTime(content, DATE_TIME_FIELDS, withOffset);
+    }
+
+    public static TextContent ofDateTime(OffsetDateTime content) {
+        return ofOffsetDateTime(content, DATE_TIME_FIELDS, WITH_TIME_OFFSET);
+    }
+
+    public static TextContent ofDateTimeList(List<OffsetDateTime> content, boolean withOffset) {
+        return ofOffsetDateTimeList(content, DATE_TIME_FIELDS, withOffset);
+    }
+
+    public static TextContent ofDateTimeList(List<OffsetDateTime> content) {
+        return ofOffsetDateTimeList(content, DATE_TIME_FIELDS, WITH_TIME_OFFSET);
+    }
+
+    public static TextContent ofTime(OffsetDateTime content, boolean withOffset) {
+        return ofOffsetDateTime(content, TIME_FIELDS, withOffset);
+    }
+
+    public static TextContent ofTime(OffsetDateTime content) {
+        return ofOffsetDateTime(content, TIME_FIELDS, WITH_TIME_OFFSET);
+    }
+
+    public static TextContent ofTimeList(List<OffsetDateTime> content, boolean withOffset) {
+        return ofOffsetDateTimeList(content, TIME_FIELDS, withOffset);
+    }
+
+    public static TextContent ofTimeList(List<OffsetDateTime> content) {
+        return ofOffsetDateTimeList(content, TIME_FIELDS, WITH_TIME_OFFSET);
+    }
+
+    public static TextContent ofDate(OffsetDateTime content, boolean withOffset) {
+        return ofOffsetDateTime(content, DATE_FIELDS, withOffset);
+    }
+
+    public static TextContent ofDate(OffsetDateTime content) {
+        return ofOffsetDateTime(content, DATE_FIELDS, WITH_DATE_OFFSET);
+    }
+
+    public static TextContent ofDateList(List<OffsetDateTime> content, boolean withOffset) {
+        return ofOffsetDateTimeList(content, DATE_FIELDS, withOffset);
+    }
+
+    public static TextContent ofDateList(List<OffsetDateTime> content) {
+        return ofOffsetDateTimeList(content, DATE_FIELDS, WITH_DATE_OFFSET);
+    }
+
+    public static TextContent ofGYearMonth(OffsetDateTime content, boolean withOffset) {
+        return ofOffsetDateTime(content, GYEAR_MONTH_FIELDS, withOffset);
+    }
+
+    public static TextContent ofGYearMonth(OffsetDateTime content) {
+        return ofOffsetDateTime(content, GYEAR_MONTH_FIELDS, WITH_DATE_OFFSET);
+    }
+
+    public static TextContent ofGYearMonthList(List<OffsetDateTime> content, boolean withOffset) {
+        return ofOffsetDateTimeList(content, GYEAR_MONTH_FIELDS, withOffset);
+    }
+
+    public static TextContent ofGYearMonthList(List<OffsetDateTime> content) {
+        return ofOffsetDateTimeList(content, GYEAR_MONTH_FIELDS, WITH_DATE_OFFSET);
+    }
+
+    public static TextContent ofGMonthDay(OffsetDateTime content, boolean withOffset) {
+        return ofOffsetDateTime(content, GMONTH_DAY_FIELDS, withOffset);
+    }
+
+    public static TextContent ofGMonthDay(OffsetDateTime content) {
+        return ofOffsetDateTime(content, GMONTH_DAY_FIELDS, WITH_DATE_OFFSET);
+    }
+
+    public static TextContent ofGMonthDayList(List<OffsetDateTime> content, boolean withOffset) {
+        return ofOffsetDateTimeList(content, GMONTH_DAY_FIELDS, withOffset);
+    }
+
+    public static TextContent ofGMonthDayList(List<OffsetDateTime> content) {
+        return ofOffsetDateTimeList(content, GMONTH_DAY_FIELDS, WITH_DATE_OFFSET);
+    }
+
+    public static TextContent ofGDay(OffsetDateTime content, boolean withOffset) {
+        return ofOffsetDateTime(content, GDAY_FIELDS, withOffset);
+    }
+
+    public static TextContent ofGDay(OffsetDateTime content) {
+        return ofOffsetDateTime(content, GDAY_FIELDS, WITH_DATE_OFFSET);
+    }
+
+    public static TextContent ofGDayList(List<OffsetDateTime> content, boolean withOffset) {
+        return ofOffsetDateTimeList(content, GDAY_FIELDS, withOffset);
+    }
+
+    public static TextContent ofGDayList(List<OffsetDateTime> content) {
+        return ofOffsetDateTimeList(content, GDAY_FIELDS, WITH_DATE_OFFSET);
+    }
+
+    public static TextContent ofGMonth(OffsetDateTime content, boolean withOffset) {
+        return ofOffsetDateTime(content, GMONTH_FIELDS, withOffset);
+    }
+
+    public static TextContent ofGMonth(OffsetDateTime content) {
+        return ofOffsetDateTime(content, GMONTH_FIELDS, WITH_DATE_OFFSET);
+    }
+
+    public static TextContent ofGMonthList(List<OffsetDateTime> content, boolean withOffset) {
+        return ofOffsetDateTimeList(content, GMONTH_FIELDS, withOffset);
+    }
+
+    public static TextContent ofGMonthList(List<OffsetDateTime> content) {
+        return ofOffsetDateTimeList(content, GMONTH_FIELDS, WITH_DATE_OFFSET);
+    }
+
+    public static TextContent ofGYear(OffsetDateTime content, boolean withOffset) {
+        return ofOffsetDateTime(content, GYEAR_FIELDS, withOffset);
+    }
+
+    public static TextContent ofGYear(OffsetDateTime content) {
+        return ofOffsetDateTime(content, GYEAR_FIELDS, WITH_DATE_OFFSET);
+    }
+
+    public static TextContent ofGYearList(List<OffsetDateTime> content, boolean withOffset) {
+        return ofOffsetDateTimeList(content, GYEAR_FIELDS, withOffset);
+    }
+
+    public static TextContent ofGYearList(List<OffsetDateTime> content) {
+        return ofOffsetDateTimeList(content, GYEAR_FIELDS, WITH_DATE_OFFSET);
+    }
+
+    public boolean isEmpty() {
+        return this == EMPTY;
+    }
+
+    public TextContent trim() {
+        content = trimmedContent();
+        return this;
+    }
+
+    public TextContent normalize() {
+        int length = content.length();
+        if (length != 0) {
+            StringBuilder normalized = new StringBuilder(length);
+            for (int i = 0; i < length; i++) {
+                char ch = content.charAt(i);
+                normalized.append(isWhiteSpace(ch) ? ' ' : ch);
+            }
+
+            content = normalized.toString();
+        }
+
+        return this;
+    }
+
+    public TextContent collapse() {
+        int length = content.length();
+        if (length != 0) {
+            char ch = 0;
+            int i = 0;
+
+            for (; i < length; i++) {
+                ch = content.charAt(i);
+                if (!isWhiteSpace(ch))
+                    break;
+            }
+
+            if (i != length) {
+                StringBuilder collapsed = new StringBuilder(length - i).append(ch);
+                boolean isWhiteSpace = false;
+
+                for (i += 1; i < length; i++) {
+                    ch = content.charAt(i);
+                    if (isWhiteSpace(ch)) {
+                        isWhiteSpace = true;
+                    } else {
+                        if (isWhiteSpace) {
+                            collapsed.append(' ');
+                            isWhiteSpace = false;
+                        }
+
+                        collapsed.append(ch);
+                    }
+                }
+
+                content = trimmedContent = collapsed.toString();
+            } else
+                content = trimmedContent = "";
+        }
+
+        return this;
+    }
+
+    public TextContent filter(Predicate<TextContent> predicate) {
+        return predicate.test(this) ? this : EMPTY;
+    }
+
+    public String get() {
+        return isPresent() ? content : null;
+    }
+
+    public boolean isPresent() {
+        return this != EMPTY;
+    }
+
+    public void ifPresent(Consumer<String> action) {
+        if (isPresent())
+            action.accept(content);
+    }
+
+    @SuppressWarnings("unchecked")
+    public List<String> getAsList() {
+        if (isListOfType(value, String.class)) {
+            return (List<String>) value;
+        } else if (tokenizeContent() != 0) {
+            List<String> strings = new ArrayList<>(tokenizedContent.length);
+            Collections.addAll(strings, tokenizedContent);
+            return setValue(strings);
+        } else {
+            return setValue(null);
+        }
+    }
+
+    public boolean isList() {
+        return getAsList() != null;
+    }
+
+    public void ifList(Consumer<List<String>> action) {
+        List<String> value = getAsList();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public Boolean getAsBoolean() {
+        return value instanceof Boolean bool ? bool : setValue(toBoolean(trimmedContent()));
+    }
+
+    public boolean isBoolean() {
+        return getAsBoolean() != null;
+    }
+
+    public void ifBoolean(Consumer<Boolean> action) {
+        Boolean value = getAsBoolean();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public List<Boolean> getAsBooleanList() {
+        if (isListOfType(value, Boolean.class)) {
+            return (List<Boolean>) value;
+        } else if (tokenizeContent() != 0) {
+            List<Boolean> booleans = new ArrayList<>(tokenizedContent.length);
+            for (String token : tokenizedContent) {
+                Boolean value = toBoolean(token);
+                if (value != null) {
+                    booleans.add(value);
+                } else {
+                    return setValue(null);
+                }
+            }
+
+            return setValue(booleans);
+        } else {
+            return setValue(null);
+        }
+    }
+
+    public boolean isBooleanList() {
+        return getAsBooleanList() != null;
+    }
+
+    public void ifBooleanList(Consumer<List<Boolean>> action) {
+        List<Boolean> value = getAsBooleanList();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public Double getAsDouble() {
+        if (value instanceof Double doubleValue) {
+            return doubleValue;
+        } else if (!isEmpty() && !trimmedContent().isEmpty()) {
+            try {
+                return setValue(Double.parseDouble(trimmedContent));
+            } catch (NumberFormatException e) {
+                return setValue(null);
+            }
+        } else {
+            return setValue(null);
+        }
+    }
+
+    public boolean isDouble() {
+        return getAsDouble() != null;
+    }
+
+    public void ifDouble(Consumer<Double> action) {
+        Double value = getAsDouble();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public List<Double> getAsDoubleList() {
+        if (isListOfType(value, Double.class)) {
+            return (List<Double>) value;
+        } else if (tokenizeContent() != 0) {
+            List<Double> doubles = new ArrayList<>(tokenizedContent.length);
+            for (String token : tokenizedContent) {
+                try {
+                    doubles.add(Double.parseDouble(token));
+                } catch (NumberFormatException e) {
+                    return setValue(null);
+                }
+            }
+
+            return setValue(doubles);
+        } else {
+            return setValue(null);
+        }
+    }
+
+    public boolean isDoubleList() {
+        return getAsDoubleList() != null;
+    }
+
+    public void ifDoubleList(Consumer<List<Double>> action) {
+        List<Double> value = getAsDoubleList();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public Integer getAsInteger() {
+        if (value instanceof Integer intValue) {
+            return intValue;
+        } else if (!isEmpty() && !trimmedContent().isEmpty()) {
+            try {
+                return setValue(Integer.parseInt(trimmedContent));
+            } catch (NumberFormatException e) {
+                return setValue(null);
+            }
+        } else {
+            return setValue(null);
+        }
+    }
+
+    public boolean isInteger() {
+        return getAsInteger() != null;
+    }
+
+    public void ifInteger(Consumer<Integer> action) {
+        Integer value = getAsInteger();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public List<Integer> getAsIntegerList() {
+        if (isListOfType(value, Integer.class)) {
+            return (List<Integer>) value;
+        } else if (tokenizeContent() != 0) {
+            List<Integer> integers = new ArrayList<>(tokenizedContent.length);
+            for (String token : tokenizedContent) {
+                try {
+                    integers.add(Integer.parseInt(token));
+                } catch (NumberFormatException e) {
+                    return setValue(null);
+                }
+            }
+
+            return setValue(integers);
+        } else {
+            return setValue(null);
+        }
+    }
+
+    public boolean isIntegerList() {
+        return getAsIntegerList() != null;
+    }
+
+    public void ifIntegerList(Consumer<List<Integer>> action) {
+        List<Integer> value = getAsIntegerList();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public Duration getAsDuration() {
+        if (value instanceof Duration duration) {
+            return duration;
+        } else if (!isEmpty() && !trimmedContent().isEmpty()) {
+            try {
+                return setValue(XML_TYPE_FACTORY.newDuration(trimmedContent));
+            } catch (Throwable e) {
+                return setValue(null);
+            }
+        } else {
+            return setValue(null);
+        }
+    }
+
+    public boolean isDuration() {
+        return getAsDuration() != null;
+    }
+
+    public void ifDuration(Consumer<Duration> action) {
+        Duration value = getAsDuration();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public List<Duration> getAsDurationList() {
+        if (isListOfType(value, Duration.class)) {
+            return (List<Duration>) value;
+        } else if (tokenizeContent() != 0) {
+            List<Duration> durations = new ArrayList<>(tokenizedContent.length);
+            for (String token : tokenizedContent) {
+                try {
+                    durations.add(XML_TYPE_FACTORY.newDuration(token));
+                } catch (Throwable e) {
+                    return setValue(null);
+                }
+            }
+
+            return setValue(durations);
+        } else {
+            return setValue(null);
+        }
+    }
+
+    public boolean isDurationList() {
+        return getAsDurationList() != null;
+    }
+
+    public void ifDurationList(Consumer<List<Duration>> action) {
+        List<Duration> value = getAsDurationList();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public OffsetDateTime getAsDateTime() {
+        return getAsOffsetDateTime("dateTime");
+    }
+
+    public boolean isDateTime() {
+        return getAsDateTime() != null;
+    }
+
+    public void ifDateTime(Consumer<OffsetDateTime> action) {
+        OffsetDateTime value = getAsDateTime();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public List<OffsetDateTime> getAsDateTimeList() {
+        return getAsOffsetDateTimeList("dateTime");
+    }
+
+    public boolean isDateTimeList() {
+        return getAsDateTimeList() != null;
+    }
+
+    public void ifDateTimeList(Consumer<List<OffsetDateTime>> action) {
+        List<OffsetDateTime> value = getAsDateTimeList();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public OffsetDateTime getAsTime() {
+        return getAsOffsetDateTime("time");
+    }
+
+    public boolean isTime() {
+        return getAsTime() != null;
+    }
+
+    public void ifTime(Consumer<OffsetDateTime> action) {
+        OffsetDateTime value = getAsTime();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public List<OffsetDateTime> getAsTimeList() {
+        return getAsOffsetDateTimeList("time");
+    }
+
+    public boolean isTimeList() {
+        return getAsTimeList() != null;
+    }
+
+    public void ifTimeList(Consumer<List<OffsetDateTime>> action) {
+        List<OffsetDateTime> value = getAsTimeList();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public OffsetDateTime getAsDate() {
+        return getAsOffsetDateTime("date");
+    }
+
+    public boolean isDate() {
+        return getAsDate() != null;
+    }
+
+    public void ifDate(Consumer<OffsetDateTime> action) {
+        OffsetDateTime value = getAsDate();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public List<OffsetDateTime> getAsDateList() {
+        return getAsOffsetDateTimeList("date");
+    }
+
+    public boolean isDateList() {
+        return getAsDateList() != null;
+    }
+
+    public void ifDateList(Consumer<List<OffsetDateTime>> action) {
+        List<OffsetDateTime> value = getAsDateList();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public OffsetDateTime getAsGYearMonth() {
+        return getAsOffsetDateTime("gYearMonth");
+    }
+
+    public boolean isGYearMonth() {
+        return getAsGYearMonth() != null;
+    }
+
+    public void ifGYearMonth(Consumer<OffsetDateTime> action) {
+        OffsetDateTime value = getAsGYearMonth();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public List<OffsetDateTime> getAsGYearMonthList() {
+        return getAsOffsetDateTimeList("gYearMonth");
+    }
+
+    public boolean isGYearMonthList() {
+        return getAsGYearMonthList() != null;
+    }
+
+    public void ifGYearMonthList(Consumer<List<OffsetDateTime>> action) {
+        List<OffsetDateTime> value = getAsGYearMonthList();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public OffsetDateTime getAsGMonthDay() {
+        return getAsOffsetDateTime("gMonthDay");
+    }
+
+    public boolean isGMonthDay() {
+        return getAsGMonthDay() != null;
+    }
+
+    public void ifGMonthDay(Consumer<OffsetDateTime> action) {
+        OffsetDateTime value = getAsGMonthDay();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public List<OffsetDateTime> getAsGMonthDayList() {
+        return getAsOffsetDateTimeList("gMonthDay");
+    }
+
+    public boolean isGMonthDayList() {
+        return getAsGMonthDayList() != null;
+    }
+
+    public void ifGMonthDayList(Consumer<List<OffsetDateTime>> action) {
+        List<OffsetDateTime> value = getAsGMonthDayList();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public OffsetDateTime getAsGDay() {
+        return getAsOffsetDateTime("gDay");
+    }
+
+    public boolean isGDay() {
+        return getAsGDay() != null;
+    }
+
+    public void ifGDay(Consumer<OffsetDateTime> action) {
+        OffsetDateTime value = getAsGDay();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public List<OffsetDateTime> getAsGDayList() {
+        return getAsOffsetDateTimeList("gDay");
+    }
+
+    public boolean isGDayList() {
+        return getAsGDayList() != null;
+    }
+
+    public void ifGDayList(Consumer<List<OffsetDateTime>> action) {
+        List<OffsetDateTime> value = getAsGDayList();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public OffsetDateTime getAsGMonth() {
+        return getAsOffsetDateTime("gMonth");
+    }
+
+    public boolean isGMonth() {
+        return getAsGMonth() != null;
+    }
+
+    public void ifGMonth(Consumer<OffsetDateTime> action) {
+        OffsetDateTime value = getAsGMonth();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public List<OffsetDateTime> getAsGMonthList() {
+        return getAsOffsetDateTimeList("gMonth");
+    }
+
+    public boolean isGMonthList() {
+        return getAsGMonthList() != null;
+    }
+
+    public void ifGMonthList(Consumer<List<OffsetDateTime>> action) {
+        List<OffsetDateTime> value = getAsGMonthList();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public OffsetDateTime getAsGYear() {
+        return getAsOffsetDateTime("gYear");
+    }
+
+    public boolean isGYear() {
+        return getAsGYear() != null;
+    }
+
+    public void ifGYear(Consumer<OffsetDateTime> action) {
+        OffsetDateTime value = getAsGYear();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public List<OffsetDateTime> getAsGYearList() {
+        return getAsOffsetDateTimeList("gYear");
+    }
+
+    public boolean isGYearList() {
+        return getAsGYearList() != null;
+    }
+
+    public void ifGYearList(Consumer<List<OffsetDateTime>> action) {
+        List<OffsetDateTime> value = getAsGYearList();
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public TextContent withZoneOffsetProvider(Function<LocalDateTime, ZoneOffset> zoneOffsetProvider) {
+        if (zoneOffsetProvider != null) {
+            this.zoneOffsetProvider = zoneOffsetProvider;
+        }
+
+        return this;
+    }
+
+    private OffsetDateTime getAsOffsetDateTime(String localName) {
+        if (value instanceof XMLGregorianCalendar calendar
+                && calendar.getXMLSchemaType().getLocalPart().equals(localName)) {
+            return toOffsetDateTime((XMLGregorianCalendar) value);
+        } else if (!isEmpty() && !trimmedContent().isEmpty()) {
+            XMLGregorianCalendar calendar = setValue(toCalendar(trimmedContent(), localName));
+            return calendar != null ? toOffsetDateTime(calendar) : null;
+        } else {
+            return setValue(null);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private List<OffsetDateTime> getAsOffsetDateTimeList(String localName) {
+        List<XMLGregorianCalendar> calendars;
+        if (value instanceof List<?> list
+                && list.stream().allMatch(v -> v instanceof XMLGregorianCalendar calendar
+                && calendar.getXMLSchemaType().getLocalPart().equals(localName))) {
+            calendars = (List<XMLGregorianCalendar>) value;
+        } else if (tokenizeContent() != 0) {
+            calendars = new ArrayList<>(tokenizedContent.length);
+            for (String token : tokenizedContent) {
+                XMLGregorianCalendar value = toCalendar(token, localName);
+                if (value != null) {
+                    calendars.add(value);
+                } else {
+                    return setValue(null);
+                }
+            }
+
+            setValue(calendars);
+        } else {
+            return setValue(null);
+        }
+
+        List<OffsetDateTime> result = new ArrayList<>(calendars.size());
+        for (XMLGregorianCalendar calendar : calendars) {
+            result.add(toOffsetDateTime(calendar));
+        }
+
+        return result;
+    }
+
+    private <T> T setValue(T value) {
+        this.value = value;
+        return value;
+    }
+
+    private boolean isListOfType(Object value, Class<?> type) {
+        return value instanceof List<?> list && list.stream().allMatch(type::isInstance);
+    }
+
+    private Boolean toBoolean(String value) {
+        if (value.isEmpty()) {
+            return null;
+        } else if ("true".equals(value)
+                || "1".equals(value)) {
+            return Boolean.TRUE;
+        } else if ("false".equals(value)
+                || "0".equals(value)) {
+            return Boolean.FALSE;
+        } else {
+            return null;
+        }
+    }
+
+    private XMLGregorianCalendar toCalendar(String value, String localName) {
+        try {
+            XMLGregorianCalendar calendar = XML_TYPE_FACTORY.newXMLGregorianCalendar(value);
+            if (calendar.getXMLSchemaType().getLocalPart().equals(localName)) {
+                return calendar;
+            }
+        } catch (Throwable e) {
+            //
+        }
+
+        return null;
+    }
+
+    private OffsetDateTime toOffsetDateTime(XMLGregorianCalendar calendar) {
+        int day = calendar.getDay();
+        int month = calendar.getMonth();
+        int year = calendar.getYear();
+        int hour = calendar.getHour();
+        int minute = calendar.getMinute();
+        int second = calendar.getSecond();
+        int offset = calendar.getTimezone();
+
+        BigDecimal fractional = calendar.getFractionalSecond();
+        int nano = fractional != null ? (int) (fractional.doubleValue() * 1e+9) : DatatypeConstants.FIELD_UNDEFINED;
+
+        LocalDateTime dateTime = LocalDateTime.of(
+                year != DatatypeConstants.FIELD_UNDEFINED ? year : 0,
+                month != DatatypeConstants.FIELD_UNDEFINED ? month : 1,
+                day != DatatypeConstants.FIELD_UNDEFINED ? day : 1,
+                hour != DatatypeConstants.FIELD_UNDEFINED ? hour : 0,
+                minute != DatatypeConstants.FIELD_UNDEFINED ? minute : 0,
+                second != DatatypeConstants.FIELD_UNDEFINED ? second : 0,
+                nano != DatatypeConstants.FIELD_UNDEFINED ? nano : 0);
+
+        return OffsetDateTime.of(dateTime, offset != DatatypeConstants.FIELD_UNDEFINED ?
+                ZoneOffset.ofTotalSeconds(offset * 60) :
+                zoneOffsetProvider.apply(dateTime));
+    }
+
+    private static TextContent ofObject(Object content) {
+        return content != null ? new TextContent(content.toString()) : EMPTY;
+    }
+
+    private static TextContent ofObjectList(List<?> content) {
+        if (content != null && !content.isEmpty()) {
+            StringBuilder builder = new StringBuilder(content.size());
+            boolean first = true;
+
+            for (Object object : content) {
+                if (object != null) {
+                    if (!first) {
+                        builder.append(" ");
+                    } else {
+                        first = false;
+                    }
+
+                    builder.append(object);
+                }
+            }
+
+            return new TextContent(builder.toString());
+        } else {
+            return EMPTY;
+        }
+    }
+
+    private static TextContent ofOffsetDateTime(OffsetDateTime content, EnumSet<Fields> fields, boolean withOffset) {
+        XMLGregorianCalendar calendar = toCalendar(content, fields, withOffset);
+        return calendar != null ? new TextContent(calendar.toXMLFormat()) : EMPTY;
+    }
+
+    private static TextContent ofOffsetDateTimeList(List<OffsetDateTime> content, EnumSet<Fields> fields, boolean withOffset) {
+        if (content != null && !content.isEmpty()) {
+            StringBuilder builder = new StringBuilder(content.size());
+            boolean first = true;
+
+            for (OffsetDateTime dateTime : content) {
+                XMLGregorianCalendar calendar = toCalendar(dateTime, fields, withOffset);
+                if (calendar != null) {
+                    if (!first) {
+                        builder.append(" ");
+                    } else {
+                        first = false;
+                    }
+
+                    builder.append(calendar.toXMLFormat());
+                }
+            }
+
+            return new TextContent(builder.toString());
+        } else {
+            return EMPTY;
+        }
+    }
+
+    private static XMLGregorianCalendar toCalendar(OffsetDateTime dateTime, EnumSet<Fields> fields, boolean withOffset) {
+        XMLGregorianCalendar calendar = null;
+        if (dateTime != null) {
+            calendar = XML_TYPE_FACTORY.newXMLGregorianCalendar(
+                    fields.contains(Fields.YEAR) ? dateTime.getYear() : DatatypeConstants.FIELD_UNDEFINED,
+                    fields.contains(Fields.MONTH) ? dateTime.getMonthValue() : DatatypeConstants.FIELD_UNDEFINED,
+                    fields.contains(Fields.DAY) ? dateTime.getDayOfMonth() : DatatypeConstants.FIELD_UNDEFINED,
+                    fields.contains(Fields.HOUR) ? dateTime.getHour() : DatatypeConstants.FIELD_UNDEFINED,
+                    fields.contains(Fields.MINUTE) ? dateTime.getMinute() : DatatypeConstants.FIELD_UNDEFINED,
+                    fields.contains(Fields.SECOND) ? dateTime.getSecond() : DatatypeConstants.FIELD_UNDEFINED,
+                    DatatypeConstants.FIELD_UNDEFINED,
+                    withOffset && fields.contains(Fields.TIMEZONE) ?
+                            dateTime.getOffset().getTotalSeconds() / 60 :
+                            DatatypeConstants.FIELD_UNDEFINED);
+
+            if (fields.contains(Fields.NANO) && dateTime.getNano() != 0) {
+                calendar.setFractionalSecond(BigDecimal.valueOf(dateTime.getNano(), 9).stripTrailingZeros());
+            }
+        }
+
+        return calendar;
+    }
+
+    public static void setZoneOffsetProvider(Function<LocalDateTime, ZoneOffset> zoneOffsetProvider) {
+        if (zoneOffsetProvider != null) {
+            ZONE_OFFSET_PROVIDER = zoneOffsetProvider;
+        }
+    }
+
+    public static void serializeTimeWithOffset(boolean useTimeOffset) {
+        WITH_TIME_OFFSET = useTimeOffset;
+    }
+
+    public static void serializeDateWithOffset(boolean useDateOffset) {
+        WITH_DATE_OFFSET = useDateOffset;
+    }
+
+    private String trimmedContent() {
+        if (trimmedContent == null) {
+            trimmedContent = content.trim();
+        }
+
+        return trimmedContent;
+    }
+
+    private int tokenizeContent() {
+        if (tokenizedContent == null) {
+            int length = content.length();
+            String[] tokens = new String[(length / 2) + 1];
+            int noOfTokens = 0;
+            int current = -1;
+            int next;
+
+            do {
+                next = nextWhiteSpace(content, current + 1, length);
+                if (next != current + 1) {
+                    tokens[noOfTokens++] = content.substring(current + 1, next);
+                }
+
+                current = next;
+            } while (next != length);
+
+            tokenizedContent = new String[noOfTokens];
+            System.arraycopy(tokens, 0, tokenizedContent, 0, noOfTokens);
+        }
+
+        return tokenizedContent.length;
+    }
+
+    private int nextWhiteSpace(String value, int pos, int length) {
+        for (int i = pos; i < length; i++) {
+            if (isWhiteSpace(value.charAt(i))) {
+                return i;
+            }
+        }
+
+        return length;
+    }
+
+    private boolean isWhiteSpace(char ch) {
+        return ch == ' ' || ch == '\n' || Character.isWhitespace(ch);
+    }
+
+    @Override
+    public String toString() {
+        return content;
+    }
+}
+

CityDoctorParent/CityDoctorModel/src/main/resources/CityDoctorLocalization.properties

-CityDoctorValidation.Version=${versionString}
-DistanceError.distanceFromPlane=distance from plane
-AboutDialog.developedBy=Developed by
+AboutDialog.closeBtn=Close
 AboutDialog.contact=Contact
+AboutDialog.developedBy=Developed by
 AboutDialog.title=CityDoctor 3 - About
-AboutDialog.closeBtn=Close
-CheckDialog.title=Check Configuration
-CheckDialog.schematronFiles=Schematron Files
-CheckDialog.schematronChooserTitle=Choose schematron file..
-CheckDialog.validationConfiguration=Validation Configuration
-CheckDialog.startingChecks=Starting checks
-CheckDialog.checksDone=Checks done
-CheckDialog.failedChecks=Failed to execute checks
-CheckDialog.schematronFileNotExisting=Schematron file does not exist, ignoring
+CheckContainer.error=Unexpected exception while executing check: {}
+CheckDialog.availableChecksLabel=Available Checks
+CheckDialog.cancelBtn=Cancel
+CheckDialog.checkBtn=Check
+CheckDialog.checkDescriptionsLabel=Explanations for the requirements are available on CityDoctor's homepage
 CheckDialog.checkEnabled=Enabled
 CheckDialog.checkName=Name
-CheckDialog.parameterValue=Value
+CheckDialog.checksDone=Checks done
+CheckDialog.checksReenabledAlert=Some checks have been reenabled so that other wanted checks can be executed\nSee the log for more information.
+CheckDialog.checksTab=Checks
+CheckDialog.clickHereToOpen=[Click here to open]
+CheckDialog.failedChecks=Failed to execute checks
+CheckDialog.filterTab=Filter
+CheckDialog.geometricChecksLabel=Geometric Checks
+CheckDialog.globalParametersLabel=Global Parameters
+CheckDialog.homepageHyperlink=https://transfer.hft-stuttgart.de/pages/citydoctor/citydoctorhomepage/en/requirements/
+CheckDialog.noPathError=Output path is missing!
+CheckDialog.outputPathBtn=Select
+CheckDialog.outputPathLabel=Output directory (Required):
 CheckDialog.parameterUnit=Unit
+CheckDialog.parameterValue=Value
+CheckDialog.pdfReportsOption=Create PDF reports
+CheckDialog.schematronChooserTitle=Choose schematron file ...
+CheckDialog.schematronFileLabel=Schematron File:
+CheckDialog.schematronFileNotExisting=Schematron file does not exist, Schematron will be skipped
+CheckDialog.schematronFiles=Schematron Files
+CheckDialog.selectAllChecksBtn=Select All
+CheckDialog.selectBtn=Select
+CheckDialog.semanticChecksLabel=Semantic Checks
+CheckDialog.startingChecks=Starting checks
+CheckDialog.streamCheckLabel=Citymodels are not loaded and kept in memory. Check results are saved to the QualityADE in copies of the input files.
+CheckDialog.streamCheckOption=Use low memory mode
+CheckDialog.title=Check Configuration
+CheckDialog.unselectAllChecksBtn=Unselect All
+CheckDialog.validationConfiguration=Validation Configuration
+CheckDialog.xmlReportsOption=Create XML reports
+Checker.checkFeature=Checking feature: {}
+Checker.checksFinished=Finished executing checks. Total time: {0}
+Checker.dbStillUnresponsive=Checker still unable to load some CityObjects from database!
+Checker.dbUnresponsive=Checker could not load some CityObjects from database!
+Checker.executeCheck=Executing check: {}
+Checker.failPdf=Failed to write PDF Report.
+Checker.failReports=Failed to write reports.
+Checker.failXml=Failed to write XML Error Report.
+Checker.finishedSchematron=Finished Schematron validation
+Checker.futuresCheckFailures=Encountered check failures due to the following errors:
+Checker.noCheckSatisfiesRequirement=Could not find any check that satisfies requirement {}, it will not be checked
+Checker.schematronCompleted=Schematron completed
+Checker.schematronFileNotFound=Schematron file {} could not be found
+Checker.schematronInterrupted=Main Thread was interrupted while waiting for Schematron
+Checker.schematronStillRunning=Schematron is still running. Waiting for completion, this may take some time
+Checker.schematronValidation=Schematron-validation thread started
+Checker.shutdownInterrupted=Main Thread got interrupted during ThreadPool shutdown
+Checker.validationInterrupted=Validation aborted: Checker got interrupted
+Checker.waitAndRetry=Waiting a second before retrying...
+Checks.missingCheck=Could not find check for id: {}
+CityDoctorController.exportSuccess=Successfully exported feature
 CityDoctorController.noDatamodel=Datamodel is null, no checks could be done
 CityDoctorController.noSourceFile=Source file is null, no checks could be done
+CityDoctorController.noZipFile=ZIP archive is null, no checks could be done
+CityDoctorController.saveZipArchiveReports=Successfully exported validation reports!
+CityDoctorValidation.Version=${versionString}
+CityDoctorValidation.inputFileNotExisting= Input file '{}' does not exist.
+CityDoctorValidation.loadingDefaultConfig=No configuration file given, loading default configuration
+CityDoctorValidation.noConfig=No configuration file specified with -config [FILE]
+CityDoctorValidation.noInputFile=No input file specified. (-in [FILE])
+CityDoctorValidation.noOutputFile=No output file specified. (-out [FILE])
+CityDoctorValidation.notExactlyOneConfigFile=Specify exactly one file as configuration
+CityDoctorValidation.notExactlyOneInputFile=Specify exactly one file as input.
+CityDoctorValidation.notExactlyOneOutputFile=Specify exactly one file as output.
+CityDoctorValidation.notExactlyOnePDFOutput=Specify exactly one file as pdfReport
+CityDoctorValidation.notExactlyOneXMLOutput=Specify exactly one file as xmlReport
+CityDoctorValidation.wrongInputFileFormat=Input file '{}' does not end with .gml or .xml
+CityGmlFeatureMapper.crossFeatureReferencesDetected=Model has Features containing cross-feature references without their own copies of the referenced polygons
+CityGmlFeatureMapper.emptyCrossFeatureReference=Polygon {} of Feature {} is being referenced in other Features: {}
+CityGmlFeatureMapper.unresolvedReferencesDetected=Model contains polygon references that could not be found
+CityGmlParser.chunkReadFailed=Failed to read GML file in chunks, falling back to reading the complete file
+CityGmlParser.convertCrsToUtmZoneN=Converting coordinate system to UTM zone {}N
+CityGmlParser.convertCrsToUtmZoneS=Converting coordinate system to UTM zone {}S
+CityGmlParser.creating4jContextFailed=Unable to create citygml4j context
+CityGmlParser.creatingAdePluginsFailed=Unable to add ADE plugins to citygml4j
+CityGmlParser.errorReadingGmlFile=Error while reading city gml file\n{}
+CityGmlParser.errorWritingGmlFile=Error while writing city gml file\n{}
+CityGmlParser.failedEPSGParse=Could not read EPSG code, fallback to metric system
+CityGmlParser.missingCityModel=File does not contain a CityModel definition! Temporary CityModel will be created.
+CityGmlParser.missingEPSGCode=No EPSG code found, assuming metric system
+CityGmlParser.noConversionNeeded=Coordinate system is in meters, no conversion done
+CityGmlParser.notValidGmlFile=This is not a valid GML-File\n
+CityGmlParser.parsedObjects=Parsed model with {} objects
+CityGmlWriterUtils.unknownADEError= Found error {} that cannot be converted to ADE error. It will not be written
+CityGmlZipArchive.generalException=Encountered an unexpected error while reading the ZIP archive
+CityGmlZipArchive.ioError=Accessing the ZIP archive failed
+CityGmlZipArchive.malformedZipFile=Parsing of ZIP archive aborted, ZIP file is malformed!
+DatabaseHandler.batchCommitFailure=Batch-commit aborted: Critical failure while trying to write CityObject {} to database!
+DatabaseHandler.connectionFailure=Connection to embedded database could not be opened!
+DatabaseHandler.fetchErrorIdsFailure=Fetching list of GmlIDs of CityObjects with errors failed!
+DatabaseHandler.getAllCityObjectsFailure=Fetching of all CityObjects failed!
+DatabaseHandler.getBBoxIntersectFailure= Connection to database failed while trying to fetch bbox intersecting objects of CityObject {}
+DatabaseHandler.getBufferIntersectFailure=Connection to database failed while trying to fetch buffer intersecting objects of CityObject {}
+DatabaseHandler.getFeatureCountFailure=Connection to database failed while trying to get count of CityObjects!
+DatabaseHandler.marshallingFailure=Writing CityObject {} to database failed!
+DatabaseHandler.serializationFailure=Serialization of CityObject {} failed!
+DatabaseHandler.setupFailure=FATAL ERROR: Creation of embedded database failed!
+DatabaseHandler.tableFailure=FATAL ERROR: Creation of features table failed!
+DatabaseHandler.unmarshallingFailure=Loading of CityObject {} from embedded database failed!
+DatabaseSettings.invalidPath=Properties for database directory and name do not combine to a valid path. Using default value instead
+DatabaseSettings.poolSizeLessThanOne=ConnectionPoolSize property was set to be less than 1. Using default value instead
+DatabaseSettings.poolSizeNaN=ConnectionPoolSize property is not an integer. Using default value instead
+DistanceError.distanceFromPlane=distance from plane
+ErrorItemVisitor.childId=Child id
+ErrorItemVisitor.component=Component
+ErrorItemVisitor.degeneratedRing=Degenerated ring
+ErrorItemVisitor.deviation=Deviation
+ErrorItemVisitor.distance=Distance
+ErrorItemVisitor.intersection=Intersection
+ErrorItemVisitor.nameOfAttribute=Name of attribute
+ErrorItemVisitor.pointTouchesEdge=Point touches edge
+ErrorItemVisitor.triangles=Triangles
 ExceptionDialog.stacktrace=The exception stacktrace was:
-FilterPane.buildings=Buildings
+FeatureMapper.polygonUnreferenced=Polygon {} is referenced but not found in feature polygons
 FilterPane.bridges=Bridges
+FilterPane.buildings=Buildings
 FilterPane.landUse=Land Use
 FilterPane.transportation=Transportation
 FilterPane.vegetation=Vegetation
 FilterPane.water=Water
-MainToolBar.wireframe=Show/Hide Wireframe
+GeometryMapper.emptyPolygon=Found polygon without exterior ring, ignoring
+LibraryObject.fileMissing=Implicit geometry references non-existing library object file {}
+LibraryObject.parsingError=Encountered an error while parsing library object {}
 MainToolBar.culling=Enable/Disable Culling
-MainToolBar.writeReports=Write Reports
 MainToolBar.executeChecks=Execute Checks
-MainToolBar.showWorld=Show entire city model
-MainToolBar.resetCamera=Reset view
 MainToolBar.hideRoof=Show/Hide roof BoundarySurfaces
-MainWindow.missingConfig=Could not find configuration file.
-MainWindow.loadGivenFile=Loading given file, please wait 
-MainWindow.finishedLoading=Finished loading
-MainWindow.checking=Checking, please wait
-MainWindow.writeXml=Writing xml report
-MainWindow.finishedXml=Finished xml report
-MainWindow.writePdf=Writing pdf report
-MainWindow.finishedPdf=Finished pdf report
-MainWindow.loadFailed=Failed to load given gml file: {}
+MainToolBar.resetCamera=Reset view
+MainToolBar.showWorld=Show entire city model
+MainToolBar.wireframe=Show/Hide Wireframe
+MainToolBar.writeReports=Write Reports
+MainToolBar.zip=Open zip-entry selection window
 MainWindow.all=All
-MainWindow.withErrors=With errors
-MainWindow.export=Export
-OpenFileDialog.select=Select CityGML file
-MainWindow.languageChange=For the change in language to apply, restart CityDoctor2.
-MainWindow.buildingsTab=Buildings
-MainWindow.vegetationTab=Vegetation
-MainWindow.transportationTab=Transportation
-MainWindow.tunnelTab=Tunnels
+MainWindow.attributeTab=Attributes
+MainWindow.availableLabel=Available:
 MainWindow.bridgeTab=Bridges
-MainWindow.waterTab=Water
-MainWindow.terrainTab=Terrain
+MainWindow.buildingsTab=Buildings
+MainWindow.checking=Checking, please wait
 MainWindow.cityfurnitureTab=CityFurniture
-MainWindow.otherObjectsTab=Other
-MainWindow.viewLabel=View
-MainWindow.showLabel=Show:
-MainWindow.searchLabel=Search:
-MainWindow.searchBtn=Search
 MainWindow.clearBtn=Clear
+MainWindow.copyId=Copy GML-ID
+MainWindow.delete=Delete feature
+MainWindow.edgesTab=Edges
 MainWindow.errorsTab=Errors
+MainWindow.export=Export feature
+MainWindow.finishedLoading=Finished loading
+MainWindow.finishedPdf=Finished pdf report
+MainWindow.finishedXml=Finished xml report
+MainWindow.focusCityObject=Focus object
+MainWindow.globalErrorsTab=Global Errors
+MainWindow.infoTopLevelCopyID=GML-ID can only be copied from top-level object!
+MainWindow.infoTopLevelExport=Only top-level object can be exported!
+MainWindow.languageChange=For the change in language to apply, restart CityDoctor2.
+MainWindow.loadFailed=Failed to load given gml file: {}
+MainWindow.loadGivenFile=Loading given file, please wait 
+MainWindow.logTab=Log
+MainWindow.memoryLabel=Memory:
+MainWindow.missingConfig=Could not find configuration file.
+MainWindow.otherObjectsTab=Other
 MainWindow.polygonsTab=Polygons
-MainWindow.edgesTab=Edges
+MainWindow.searchBtn=Search
+MainWindow.searchLabel=Search:
+MainWindow.showLabel=Show:
+MainWindow.terrainTab=Terrain
+MainWindow.transportationTab=Transportation
+MainWindow.tunnelTab=Tunnels
+MainWindow.vegetationTab=Vegetation
 MainWindow.verticesTab=Vertices
-MainWindow.attributeTab=Attributes
-MainWindow.logTab=Log
-MainWindow.globalErrorsTab=Global Errors
+MainWindow.viewLabel=View
+MainWindow.warnCopyIdFailed=Could not copy GML-ID!
+MainWindow.waterTab=Water
+MainWindow.withErrors=With errors
+MainWindow.writePdf=Writing pdf report
+MainWindow.writeXml=Writing xml report
+OpenFileDialog.cancelBtn=Cancel
 OpenFileDialog.fileLabel=File:
-OpenFileDialog.selectBtn=Select
 OpenFileDialog.loadBtn=Load
-OpenFileDialog.settingsPane=Parser Preferences
+OpenFileDialog.loadFailed=Failed to load CityGML File
+OpenFileDialog.lowMemoryLabel=Low Memory Consumption Mode
 OpenFileDialog.roundingPlacesLabel=NumberOfRoundingPlaces
+OpenFileDialog.select=Select CityGML file
+OpenFileDialog.selectBtn=Select
+OpenFileDialog.settingsPane=Parser Preferences
 OpenFileDialog.xmlValidationLabel=Use XML Validation
-Checker.failXml=Failed to write XML Error Report.
-Checker.failPdf=Failed to write PDF Report.
-Checker.checksFinished=Finished executing checks
-Checker.schematronValidation=Starting Schematron validation
-Checker.finishedSchematron=Finished Schematron validation
-Checker.failReports=Failed to write reports.
-Checker.checkFeature=Checking feature: {}
-Checker.executeCheck=Executing check: {}
-ValidationConfiguration.reenable={} has been disabled but {} depends on it, reenabling
+TimeFormatter.hours={0} hours
+TimeFormatter.lessThanASecond=< 1 second
+TimeFormatter.minutes={0} minutes
+TimeFormatter.oneHour=1 hour
+TimeFormatter.oneMinute=1 minute
+TimeFormatter.oneSecond=1 second
+TimeFormatter.seconds={0} seconds
+Unit.Degree=Degree
+Unit.Radian=Radian
 ValidationConfiguration.missingSchematron={} is not an existing file, disabling schematron check
-CheckContainer.error=Unexpected exception while executing check: {}
-Checks.missingCheck=Could not find check for id: {}
-OpenFileDialog.cancelBtn=Cancel
-CheckDialog.checksTab=Checks
-CheckDialog.filterTab=Filter
-CheckDialog.globalParametersLabel=Global Parameters
-CheckDialog.availableChecksLabel=Available Checks
-CheckDialog.geometricChecksLabel=Geometric Checks
-CheckDialog.semanticChecksLabel=Semantic Checks
-CheckDialog.schematronFileLabel=Schematron File:
-CheckDialog.selectBtn=Select
-CheckDialog.checkBtn=Check
-CheckDialog.cancelBtn=Cancel
-WriteReportDialog.writeBtn=Save
+ValidationConfiguration.reenable={} has been disabled but {} depends on it, reenabling
 WriteReportDialog.cancelBtn=Cancel
 WriteReportDialog.errorStatisticsLabel=Error Statistics
 WriteReportDialog.saveImageBtn=Save Image...
 WriteReportDialog.selectPdfBtn=Select
 WriteReportDialog.selectXmlFile=Select
+WriteReportDialog.writeBtn=Save
 WriteReportDialog.xAxisLabel=Error
 WriteReportDialog.yAxisLabel=Count
\ No newline at end of file
-Unit.Radian=Radian
-Unit.Degree=Degree
-FeatureMapper.polygonUnreferenced=Polygon {} is referenced but not found in feature polygons
-GeometryMapper.emptyPolygon=Found polygon without exterior ring, ignoring
-CityGmlParser.parsedObjects=Parsed model with {} objects
-CityGmlParser.chunkReadFailed=Failed to read GML file in chunks, falling back to reading the complete file
-CityGmlParser.notValidGmlFile=This is not a valid GML-File\n
-CityGmlParser.errorReadingGmlFile=Error while reading city gml file\n{}
-CityGmlParser.errorWritingGmlFile=Error while writing city gml file\n{}
-CityGmlParser.noConversionNeeded=Coordinate system is in meters, no conversion done
-CityGmlParser.noEPSG=Could not read EPSG code, assuming metric system
-OpenFileDialog.loadFailed=Failed to load CityGML File
-MainWindow.memoryLabel=Memory:
-CheckDialog.checksReenabledAlert=Some checks have been reenabled so that other wanted checks can be executed\nSee the log for more information.
-MainWindow.availableLabel=Available:
-OpenFileDialog.lowMemoryLabel=Low Memory Consumption Mode
-ErrorItemVisitor.intersection=Intersection
-ErrorItemVisitor.component=Component
-ErrorItemVisitor.nameOfAttribute=Name of attribute
-ErrorItemVisitor.childId=Child id
-ErrorItemVisitor.distance=Distance
-ErrorItemVisitor.pointTouchesEdge=Point touches edge
-ErrorItemVisitor.degeneratedRing=Degenerated ring
-ErrorItemVisitor.deviation=Deviation
-ErrorItemVisitor.triangles=Triangles
\ No newline at end of file

CityDoctorParent/CityDoctorModel/src/main/resources/CityDoctorLocalization_de.properties

-DistanceError.distanceFromPlane=Abstand von der Ebene
-AboutDialog.developedBy=Entwickelt von
+AboutDialog.closeBtn=Schlie\u00DFen
 AboutDialog.contact=Kontakt
+AboutDialog.developedBy=Entwickelt von
 AboutDialog.title=CityDoctor 3 - \u00DCber
-AboutDialog.closeBtn=Schlie\u00DFen
-CheckDialog.title=Pr\u00fcfungskonfiguration
-CheckDialog.schematronFiles=Schematron Dateien
-CheckDialog.schematronChooserTitle=W\u00e4hle Schematron Datei..
-CheckDialog.validationConfiguration=Validierungs Konfiguration
-CheckDialog.startingChecks=Starte Pr\u00fcfung
+CheckContainer.error=Unerwarteter Fehler bei der Ausf\u00fchrung von Pr\u00fcfung: {}
+CheckDialog.availableChecksLabel=Verf\u00fcgbare Pr\u00fcfungen
+CheckDialog.cancelBtn=Abbrechen
+CheckDialog.checkBtn=Pr\u00fcfen
+CheckDialog.checkDescriptionsLabel=Beschreibungen der Pr\u00fcfungen sind auf der CityDoctor Homepage verf\u00fcgbar
+CheckDialog.checkEnabled=Aktiv
+CheckDialog.checkName=Name
 CheckDialog.checksDone=Pr\u00fcfung abgeschlossen
+CheckDialog.checksReenabledAlert=Manche Pr\u00fcfungen wurden reaktiviert damit andere gewollte Pr\u00fcfungen durchgef\u00fchrt werden k\u00f6nnen\nMehr Details sind im Log geschrieben
+CheckDialog.checksTab=Pr\u00fcfungen
+CheckDialog.clickHereToOpen=[Hier Klicken zum \u00d6ffnen]
 CheckDialog.failedChecks=Konnte Pr\u00fcfungen nicht ausf\u00fchren
-CheckDialog.schematronFileNotExisting=Schematron Datei existiert nicht, ignoriere
-CheckDialog.checkEnabled=Aktiv
-CheckDialog.parameterValue=Wert
+CheckDialog.filterTab=Filter
+CheckDialog.geometricChecksLabel=Geometrische Pr\u00fcfungen
+CheckDialog.globalParametersLabel=Globale Parameter
+CheckDialog.homepageHyperlink=https://transfer.hft-stuttgart.de/pages/citydoctor/citydoctorhomepage/de/requirements/
+CheckDialog.noPathError=Ausgabepfad wurde nicht gesetzt!
+CheckDialog.outputPathBtn=Ausw\u00e4hlen
+CheckDialog.outputPathLabel=Ausgabeordner (Pflichtfeld):
 CheckDialog.parameterUnit=Einheit
-CityDoctorController.noDatamodel=Datenmodell ist null, keine Pr\u00fcfungen konnten ausgef\u00fchrt werden
-CityDoctorController.noSourceFile=Quelldatei ist null, keine Pr\u00fcfungen konnten ausgef\u00fchrt werden
+CheckDialog.parameterValue=Wert
+CheckDialog.pdfReportsOption=PDF-Berichte erstellen
+CheckDialog.schematronChooserTitle=W\u00e4hle Schematron Datei ...
+CheckDialog.schematronFileLabel=Schematron Datei:
+CheckDialog.schematronFileNotExisting=Schematron Datei existiert nicht, Schematron-Pr\u00fcfung wird \u00fcbersprungen
+CheckDialog.schematronFiles=Schematron Dateien
+CheckDialog.selectAllChecksBtn=Alle aktivieren
+CheckDialog.selectBtn=Ausw\u00e4hlen
+CheckDialog.semanticChecksLabel=Semantische Pr\u00fcfungen
+CheckDialog.startingChecks=Starte Pr\u00fcfung
+CheckDialog.streamCheckLabel=Stadtmodelle werden nicht in den Arbeitsspeicher geladen. Ergebnisse werden in der QualityADE in Kopien der Eingangsdateien gespeichert.
+CheckDialog.streamCheckOption=Niedrigen Arbeitsspeicherverbrauchsmodus aktivieren
+CheckDialog.title=Pr\u00fcfungskonfiguration
+CheckDialog.unselectAllChecksBtn=Alle deaktivieren
+CheckDialog.validationConfiguration=Validierungskonfiguration
+CheckDialog.xmlReportsOption=XML-Berichte erstellen
+Checker.checkFeature=Pr\u00fcfe Feature: {}
+Checker.checksFinished=Durchf\u00fchrung der Pr\u00fcfungen abgeschlossen. Gesamtzeit: {0}
+Checker.dbStillUnresponsive=Pr\u00fcfung konnte weiterhin einige CityObjects nicht aus der Datenbank laden!
+Checker.dbUnresponsive=Pr\u00fcfung konnte einige CityObjects nicht aus der Datenbank laden!
+Checker.executeCheck=F\u00fchre Pr\u00fcfung aus: {}
+Checker.failPdf=Konnte PDF-Fehlerbericht nicht schreiben.
+Checker.failReports=Konnte Pr\u00fcfberichte nicht schreiben.
+Checker.failXml=Konnte XML-Fehlerbericht nicht schreiben.
+Checker.finishedSchematron=Schematron-Pr\u00fcfung abgeschlossen
+Checker.futuresCheckFailures=Einige Pr\u00fcfungen sind aufgrund folgender Fehler fehlgeschlagen:
+Checker.noCheckSatisfiesRequirement=Keine Pr\u00fcfung erf\u00fcllt die Anforderung {}, Anforderung wird nicht gepr\u00fcft
+Checker.schematronCompleted=Schematron-Pr\u00fcfung abgeschlossen
+Checker.schematronFileNotFound=Schematron Datei {} konnte nicht gefunden werden
+Checker.schematronInterrupted=Main Thread hat Interrupt-Befehl w\u00e4hrend dem Warten auf Schematron Abschluss erhalten!
+Checker.schematronStillRunning=Schematron-Pr\u00fcfung ist noch nicht abgeschlossen. Warten auf Abschluss der Pr\u00fcfung, dies kann einiges an Zeit beanspruchen
+Checker.schematronValidation=Schematron-Pr\u00fcfung gestartet
+Checker.shutdownInterrupted=Main-Thread hat einen Interrupt-Befehl w\u00e4hrend dem ThreadPool shutdown erhalten
+Checker.validationInterrupted=Validierung abgebrochen: Pr\u00fcfung hat Interrupt-Befehl erhalten
+Checker.waitAndRetry=Wiederhole Pr\u00fcfung nach kurzer Wartezeit ...
+Checks.missingCheck=Konnte keine Pr\u00fcfung f\u00fcr id {} finden
+CityDoctorController.exportSuccess=Exportieren des Features erfolgreich abgeschlossen
+CityDoctorController.noDatamodel=Datenmodell ist NULL, keine Pr\u00fcfungen konnten ausgef\u00fchrt werden
+CityDoctorController.noSourceFile=Quelldatei ist NULL, keine Pr\u00fcfungen konnten ausgef\u00fchrt werden
+CityDoctorController.noZipFile=ZIP-Archiv ist NULL, keine Pr\u00fcfungen konnten ausgef\u00fchrt werden
+CityDoctorController.saveZipArchiveReports=Validierungsberichte erfolgreich exportiert!
+CityDoctorValidation.Version=${versionString}
+CityDoctorValidation.inputFileNotExisting=Eingabedatei '{}' existiert nicht.
+CityDoctorValidation.loadingDefaultConfig=Keine Konfigurationsdatei angegeben, Standardkonfiguration wird geladen.
+CityDoctorValidation.noConfig=Keine Konfigurationsdatei angegeben. (-config [DATEIPFAD])
+CityDoctorValidation.noInputFile=Keine Eingabedatei angegeben. (-in [DATEIPFAD])
+CityDoctorValidation.noOutputFile=Keinen Ausgabedateipfad angegeben. (-out [DATEIPFAD])
+CityDoctorValidation.notExactlyOneConfigFile=Es muss exakt eine Konfigurationsdatei angegeben werden.
+CityDoctorValidation.notExactlyOneInputFile=Es muss exakt eine Eingabedatei angegeben werden.
+CityDoctorValidation.notExactlyOneOutputFile=Es muss exakt ein Ausgabedateipfad angegeben werden.
+CityDoctorValidation.notExactlyOnePDFOutput=Es muss exakt ein Ausgabedateipfad f\u00fcr den PDF-Bericht angegeben werden.
+CityDoctorValidation.notExactlyOneXMLOutput=Es muss exakt ein Ausgabedateipfad f\u00fcr den XML-Bericht angegeben werden.
+CityDoctorValidation.wrongInputFileFormat=Eingabedatei '{}' ist keine .gml oder .xml Datei.
+CityGmlFeatureMapper.crossFeatureReferencesDetected=Modell enth\u00e4lt Features mit Feature\u00fcbergreifenden Polygonreferenzen ohne eigene Duplikate
+CityGmlFeatureMapper.emptyCrossFeatureReference=Polygon {} in Feature {} wird Feature\u00fcbergreifend referenziert durch Features: {}
+CityGmlFeatureMapper.unresolvedReferencesDetected=Modell enth\u00e4lt Features mit Polygonreferenzen welche nicht aufgel\u00f6st werden konnten
+CityGmlParser.chunkReadFailed=Konnte Datei nicht in St\u00fccken lesen, versuche komplett zu lesen
+CityGmlParser.convertCrsToUtmZoneN=Konvertiere Koordinatensystem zu UTM Zone {}N
+CityGmlParser.convertCrsToUtmZoneS=Konvertiere Koordinatensystem zu UTM Zone {}S
+CityGmlParser.creating4jContextFailed=Erstellen des Citygml4j Kontext fehlgeschlagen
+CityGmlParser.creatingAdePluginsFailed=Erstellen des ADE Plugins f\u00fcr citygml4j fehlgeschlagen
+CityGmlParser.errorReadingGmlFile=Fehler beim lesen der CityGML Datei\n{}
+CityGmlParser.errorWritingGmlFile=Fehler beim schreiben der CityGML Datei\n{}
+CityGmlParser.failedEPSGParse=Lesen des EPSG-Codes fehlgeschlagen, greife auf metrisches System zur\u00fcck
+CityGmlParser.missingCityModel=Datei enth\u00e4lt kein CityModel! Tempor\u00e4res CityModel wird erstellt.
+CityGmlParser.missingEPSGCode=Kein EPSG-Code wurde gefunden! Gehe von metrischem System aus
+CityGmlParser.noConversionNeeded=Koordinatensystem in Metern, keine Konvertierung notwendig
+CityGmlParser.notValidGmlFile=Dies ist keine korrekte CityGML Datei
+CityGmlParser.parsedObjects=Modell mit {} Objekten gelesen
+CityGmlWriterUtils.unknownADEError= Fehler {} kann nicht zu einem ADE-Fehler konvertiert werden. Fehler wird nicht ausgegeben
+CityGmlZipArchive.generalException=Unerwarteter Fehler beim Einlesen des ZIP-Archivs
+CityGmlZipArchive.ioError=Zugriff auf ZIP-Datei fehlgeschlagen
+CityGmlZipArchive.malformedZipFile=Einlesen des ZIP-Archivs abgebrochen, ZIP-Datei ist fehlerhaft!
+DatabaseHandler.batchCommitFailure=Batch-commit abgebrochen: Auftreten eines kritischen Fehlers beim Versuch CityObject {} in die Datenbank zu schreiben!
+DatabaseHandler.connectionFailure=Verbindung zur eingebetteten Datenbank konnte nicht hergestellt werden!
+DatabaseHandler.fetchErrorIdsFailure=Abfragen der Liste von CityObjects mit Fehlern ist fehlgeschlagen!
+DatabaseHandler.getAllCityObjectsFailure=Abfragen der Liste aller CityObjects ist fehlgeschlagen!
+DatabaseHandler.getBBoxIntersectFailure=Verbindung zur Datenbank konnte nicht hergestellt werden, abfragen der BoundingBox-\u00dcberschneidungen von CityObject {} fehlgeschlagen!
+DatabaseHandler.getBufferIntersectFailure=Verbindung zur Datenbank konnte nicht hergestellt werden, abfragen der Buffer-\u00dcberschneidungen von CityObject {} fehlgeschlagen!
+DatabaseHandler.getFeatureCountFailure=Verbindung zur Datenbank konnte nicht hergestellt werden, abfragen der Anzahl an CityObjects fehlgeschlagen!
+DatabaseHandler.marshallingFailure=Schreiben des CityObject {} in die Datenbank fehlgeschlagen!
+DatabaseHandler.serializationFailure=Serialisierung des CityObject {} fehlgeschlagen!
+DatabaseHandler.setupFailure=KRITISCHER FEHLER: Erstellen der eingebetteten Datenbank fehlgeschlagen!
+DatabaseHandler.tableFailure=KRITISCHER FEHLER: Erstellen der "features" Tabelle fehlgeschlagen!
+DatabaseHandler.unmarshallingFailure=Laden des CityObject {} aus der Datenbank fehlgeschlagen!
+DatabaseSettings.invalidPath=Einstellungen f\u00fcr Directory und Name der Datenbank bilden keinen validen Pfad. Standardwerte werden stattdessen genutzt
+DatabaseSettings.poolSizeLessThanOne=ConnectionPoolSize Einstellung wurde auf unter 1 gesetzt. Standardwert wird stattdessen genutzt
+DatabaseSettings.poolSizeNaN=ConnectionPoolSize Einstellung ist kein Integer. Standardwert wird stattdessen genutzt
+DistanceError.distanceFromPlane=Abstand von der Ebene
+ErrorItemVisitor.childId=Kind ID
+ErrorItemVisitor.component=Komponente
+ErrorItemVisitor.degeneratedRing=Degenerierter Ring
+ErrorItemVisitor.deviation=Abweichung
+ErrorItemVisitor.distance=Distanz
+ErrorItemVisitor.intersection=Verschneidung
+ErrorItemVisitor.nameOfAttribute=Name des Attributs
+ErrorItemVisitor.pointTouchesEdge=Punkt ber\u00fchrt Kante
+ErrorItemVisitor.triangles=Dreiecke
 ExceptionDialog.stacktrace=Der Stacktrace des Fehlers war:
-FilterPane.buildings=Geb\u00e4ude
+FeatureMapper.polygonUnreferenced=Polygon {} wurde referenziert, konnte aber nicht gefunden werden!
 FilterPane.bridges=Br\u00fccken
+FilterPane.buildings=Geb\u00e4ude
 FilterPane.landUse=Landnutzung
 FilterPane.transportation=Transport
 FilterPane.vegetation=Vegetation
 FilterPane.water=Wasser
-MainToolBar.wireframe=Zeige/Verstecke Gitternetz
-MainToolBar.culling=Aktiviere/Deaktiviere Entfernen der R\u00fcckseiten
-MainToolBar.writeReports=Schreibe Reports
+GeometryMapper.emptyPolygon=Polygon ohne externen Ring gefunden. Polygon wird ignoriert
+LibraryObject.fileMissing=Die ImplicitGeometry eines Features verweist auf eine nicht vorhandene LibraryObject-Datei {}
+LibraryObject.parsingError=LibraryObject-Datei {} konnte aufgrund eines Fehlers nicht ausgelesen werden
+MainToolBar.culling=Aktiviere/Deaktiviere Entfernen der Polygon-R\u00fcckseiten
 MainToolBar.executeChecks=F\u00fchre Pr\u00fcfungen aus
-MainToolBar.showWorld=Gesamtes Stadtmodell anzeigen
-MainToolBar.resetCamera=Ansicht zur\u00fccksetzen
-MainToolBar.hideRoof=Zeige/Verstecke Dach BoundarySurfaces
-MainWindow.missingConfig=Konnte Konfigurationsdatei nicht finden. 
-MainWindow.loadGivenFile=Lade vorhandene Datei, bitte warten
-MainWindow.finishedLoading=Fertig geladen
-MainWindow.checking=Pr\u00fcfe, bitte warten
-MainWindow.writeXml=Schreibe Xml Report
-MainWindow.finishedXml=Xml Report abgeschlossen
-MainWindow.writePdf=Schreibe Pdf Report
-MainWindow.finishedPdf=Pdf Report abgeschlossen
-MainWindow.loadFailed=Konnte GML-Datei nicht laden: {}
+MainToolBar.hideRoof=Zeige/Verstecke Dach-BoundarySurfaces
+MainToolBar.resetCamera=Kamera-Ansicht zur\u00fccksetzen
+MainToolBar.showWorld=Zeige gesamtes Stadtmodell an
+MainToolBar.wireframe=Aktiviere/Deaktiviere Gitternetz-Modus
+MainToolBar.writeReports=Schreibe Berichte
+MainToolBar.zip=Zip-eintrag Auswahlfenster \u00f6ffnen
 MainWindow.all=Alle
-MainWindow.withErrors=Mit Fehlern
-MainWindow.export=Exportieren
-OpenFileDialog.select=W\u00e4hle CityGML Datei aus
-MainWindow.languageChange=Um die Spracheinstellung zu \u00fcbernehmen muss CityDoctor2 neugestartet werden.
-MainWindow.buildingsTab=Geb\u00e4ude
-MainWindow.vegetationTab=Vegetation
-MainWindow.transportationTab=Verkehrsobjekte
-MainWindow.tunnelTab=Tunnel
+MainWindow.attributeTab=Attribute
+MainWindow.availableLabel=Verf\u00fcgbar:
 MainWindow.bridgeTab=Br\u00fccken
-MainWindow.waterTab=Gew\u00e4sser
-MainWindow.terrainTab=Gel\u00e4nde
+MainWindow.buildingsTab=Geb\u00e4ude
+MainWindow.checking=Pr\u00fcfe, bitte warten
 MainWindow.cityfurnitureTab=Stadtm\u00f6bel
-MainWindow.otherObjectsTab=Andere
-MainWindow.viewLabel=Ansicht
-MainWindow.showLabel=Zeige:
-MainWindow.searchLabel=Suche:
-MainWindow.searchBtn=Suche
 MainWindow.clearBtn=Leeren
+MainWindow.copyId=GML-ID kopieren
+MainWindow.delete=Feature L\u00f6schen
+MainWindow.edgesTab=Kanten
 MainWindow.errorsTab=Fehler
+MainWindow.export=Feature Exportieren
+MainWindow.finishedLoading=Fertig geladen
+MainWindow.finishedPdf=Pdf-Bericht abgeschlossen
+MainWindow.finishedXml=Xml-Bericht abgeschlossen
+MainWindow.focusCityObject=Objekt fokussieren
+MainWindow.globalErrorsTab=Globale Fehler
+MainWindow.infoTopLevelCopyID=GML-ID kann nur von Featureobjekt basis kopiert werden!
+MainWindow.infoTopLevelExport=Export ist nur f\u00fcr Featureobjekt basis m\u00f6glich!
+MainWindow.languageChange=Um die Spracheinstellung zu \u00fcbernehmen muss CityDoctor2 neugestartet werden.
+MainWindow.loadFailed=Konnte GML-Datei nicht laden: {}
+MainWindow.loadGivenFile=Lade vorhandene Datei, bitte warten
+MainWindow.logTab=Log
+MainWindow.memoryLabel=Speicher:
+MainWindow.missingConfig=Konnte Konfigurationsdatei nicht finden.
+MainWindow.otherObjectsTab=Andere
 MainWindow.polygonsTab=Polygone
-MainWindow.edgesTab=Kanten
+MainWindow.searchBtn=Suche
+MainWindow.searchLabel=Suche:
+MainWindow.showLabel=Zeige:
+MainWindow.terrainTab=Gel\u00e4nde
+MainWindow.transportationTab=Verkehrsobjekte
+MainWindow.tunnelTab=Tunnel
+MainWindow.vegetationTab=Vegetation
 MainWindow.verticesTab=Punkte
-MainWindow.attributeTab=Attribute
-MainWindow.logTab=Log
-MainWindow.globalErrorsTab=Globale Fehler
+MainWindow.viewLabel=Ansicht
+MainWindow.warnCopyIdFailed=Kopieren der ID fehlgeschlagen!
+MainWindow.waterTab=Gew\u00e4sser
+MainWindow.withErrors=Mit Fehlern
+MainWindow.writePdf=Schreibe Pdf-Bericht
+MainWindow.writeXml=Schreibe Xml-Bericht
+OpenFileDialog.cancelBtn=Abbrechen
 OpenFileDialog.fileLabel=Datei:
-OpenFileDialog.selectBtn=Ausw\u00e4hlen
 OpenFileDialog.loadBtn=Laden
+OpenFileDialog.loadFailed=Konnte CityGML Datei nicht laden
+OpenFileDialog.lowMemoryLabel=Reduzierter Speicherverbrauchsmodus
+OpenFileDialog.roundingPlacesLabel=Anzahl der Rundungsstellen
+OpenFileDialog.select=W\u00e4hle CityGML Datei aus
+OpenFileDialog.selectBtn=Ausw\u00e4hlen
 OpenFileDialog.settingsPane=Parser Einstellungen
-OpenFileDialog.roundingPlacesLabel=NumberOfRoundingPlaces
 OpenFileDialog.xmlValidationLabel=F\u00fchre XML-Validierung aus
-Checker.failXml=Konnte XML Fehlerbericht nicht schreiben.
-Checker.failPdf=Konnte PDF Fehlerbericht nicht schreiben.
-Checker.checksFinished=Pr\u00fcfungen beendet
-Checker.schematronValidation=Starte Schematron Pr\u00fcfung
-Checker.finishedSchematron=Schematron Pr\u00fcfung abgeschlossen
-Checker.failReports=Konnte Pr\u00fcfberichte nicht schreiben.
-Checker.checkFeature=Pr\u00fcfe Feature: {}
-Checker.executeCheck=F\u00fchre Pr\u00fcfung aus: {}
-ValidationConfiguration.reenable={} ist deaktiviert wird aber von {} ben\u00f6tigt, reaktiviere
+TimeFormatter.hours={0} Stunden
+TimeFormatter.lessThanASecond=< 1 Sekunde
+TimeFormatter.minutes={0} Minuten
+TimeFormatter.oneHour=1 Stunde
+TimeFormatter.oneMinute=1 Minute
+TimeFormatter.oneSecond=1 Sekunde
+TimeFormatter.seconds={0} Sekunden
+Unit.Degree=Grad
+Unit.Radian=Radiant
 ValidationConfiguration.missingSchematron={} existiert nicht, deaktiviere Schematron Pr\u00fcfung
-CheckContainer.error=Unerwarteter Fehler bei der Ausf\u00fchrung von Pr\u00fcfung: {}
-Checks.missingCheck=Konnte keine Pr\u00fcfung f\u00fcr id {} finden
-OpenFileDialog.cancelBtn=Abbrechen
-CheckDialog.checksTab=Pr\u00fcfungen
-CheckDialog.filterTab=Filter
-CheckDialog.globalParametersLabel=Globale Parameter
-CheckDialog.availableChecksLabel=Verf\u00fcgbare Pr\u00fcfungen
-CheckDialog.geometricChecksLabel=Geometrische Pr\u00fcfungen
-CheckDialog.semanticChecksLabel=Semantische Pr\u00fcfungen
-CheckDialog.schematronFileLabel=Schematron Datei
-CheckDialog.selectBtn=Ausw\u00e4hlen
-CheckDialog.checkBtn=Pr\u00fcfen
-CheckDialog.cancelBtn=Abbrechen
-WriteReportDialog.writeBtn=Speichern
+ValidationConfiguration.reenable={} ist deaktiviert wird aber von {} ben\u00f6tigt, reaktiviere
 WriteReportDialog.cancelBtn=Abbrechen
 WriteReportDialog.errorStatisticsLabel=Fehler Statistik
 WriteReportDialog.saveImageBtn=Bild Speichern
 WriteReportDialog.selectPdfBtn=Ausw\u00e4hlen
 WriteReportDialog.selectXmlFile=Ausw\u00e4hlen
+WriteReportDialog.writeBtn=Speichern
 WriteReportDialog.xAxisLabel=Fehler
 WriteReportDialog.yAxisLabel=Anzahl
\ No newline at end of file
-Unit.Radian=Radiant
-Unit.Degree=Grad
-FeatureMapper.polygonUnreferenced=Polygon {} ist referenziert wurde aber nicht gefunden
-GeometryMapper.emptyPolygon=Polygon ohne externen Ring gefunden, ignoriere
-CityGmlParser.parsedObjects=Modell mit {} Objekten gelesen
-CityGmlParser.chunkReadFailed=Konnte Datei nicht in St\u00fccken lesen, versuche komplett zu lesen
-CityGmlParser.notValidGmlFile=Dies ist keine korrekte CityGML Datei\n
-CityGmlParser.errorReadingGmlFile=Fehler beim lesen der CityGML Datei\n{}
-CityGmlParser.errorWritingGmlFile=Fehler beim schreiben der CityGML Datei\n{}
-CityGmlParser.noConversionNeeded=Koordinatensystem in Metern, keine Konvertierung notwendig
-CityGmlParser.noEPSG=Konnte EPSG Code nicht lesen, nehme metrisches System an
-OpenFileDialog.loadFailed=Konnte CityGML Datei nicht laden
-MainWindow.memoryLabel=Speicher:
-CheckDialog.checksReenabledAlert=Manche Pr\u00fcfungen wurden reaktiviert damit andere gewollte Pr\u00fcfungen durchgef\u00fchrt werden k\u00f6nnen\nMehr Details sind im Log geschrieben
-MainWindow.availableLabel=Verf\u00fcgbar:
-OpenFileDialog.lowMemoryLabel=Reduzierter Speicherverbrauchsmodus
-ErrorItemVisitor.intersection=Verschneidung
-ErrorItemVisitor.component=Komponente
-ErrorItemVisitor.nameOfAttribute=Name des Attributs
-ErrorItemVisitor.childId=Kind ID
-ErrorItemVisitor.distance=Distanz
-ErrorItemVisitor.pointTouchesEdge=Punkt ber\u00fchrt Kante
-ErrorItemVisitor.degeneratedRing=Degenerierter Ring
-ErrorItemVisitor.deviation=Abweichung
-ErrorItemVisitor.triangles=Dreiecke
\ No newline at end of file

CityDoctorParent/CityDoctorModel/src/main/resources/log4j2.xml

@@ -11,5 +11,11 @@
         <Root level="debug" additivity="false">
             <AppenderRef ref="console" />
         </Root>
+        <Logger name="org.apache.fop" level="INFO"> 
+            <AppenderRef ref="console" />
+   		</Logger>
+        <Logger name="com.zaxxer.hikari" level="INFO" additivity="false">
+            <AppenderRef ref="console"/>
+        </Logger>
     </Loggers>
 </Configuration>
\ No newline at end of file