Merge branch 'dev_db_config' into 'dev'

Version 3.18.2

See merge request !39

.run/CityDoctorGUIStarter.run.xml

@@ -13,4 +13,18 @@
       <option name="Make" enabled="true" />
     </method>
   </configuration>
+  <configuration default="false" name="CityDoctorGUIStarter" type="Application" factoryName="Application" nameIsGenerated="true">
+    <option name="MAIN_CLASS_NAME" value="de.hft.stuttgart.citydoctor2.gui.CityDoctorGUIStarter" />
+    <module name="CityDoctorGUI" />
+    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/CityDoctorParent/Extensions/CityDoctorGUI" />
+    <extension name="coverage">
+      <pattern>
+        <option name="PATTERN" value="de.hft.stuttgart.citydoctor2.gui.*" />
+        <option name="ENABLED" value="true" />
+      </pattern>
+    </extension>
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
 </component>
\ No newline at end of file

CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.18.2] (2026-02-24)
+
+### Added
+- CLI parameter "-db_location" for changing the location of the database-file of the embedded database. This parameter will
+override the location settings of the DB-settings file.
+- CLI parameter "-db_settings" for giving a path to a DB-settings .properties file.
+- Added -db_location pointing to the system's temp directory to the start scripts for the binaries
+- Added buttons for (un)checking all Geometric or Semantic requirements
+- Added a Hyperlink to CityDoctor's homepage with detailed explanations for each requirement
+- The GUI will now show a loading spinner while waiting for Schematron to finish.
+
+
+### Fixes
+- Connected CityDoctorHealer to the embedded database
+- Various small fixes and improvements to performance
+
 ## [3.18.1] (2025-12-10)
 
 ### Hotfix

CityDoctorParent/CityDoctorCheckResult/pom.xml

@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>de.hft.stuttgart</groupId>
 		<artifactId>CityDoctorParent</artifactId>
-		<version>3.18.1</version>
+		<version>3.18.2</version>
 	</parent>
 	<artifactId>CityDoctorCheckResult</artifactId>
 	<dependencies>

CityDoctorParent/CityDoctorEdge/pom.xml

@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>de.hft.stuttgart</groupId>
 		<artifactId>CityDoctorParent</artifactId>
-		<version>3.18.1</version>
+		<version>3.18.2</version>
 	</parent>
 	<artifactId>CityDoctorEdge</artifactId>
 	<dependencies>

CityDoctorParent/CityDoctorEdge/src/test/java/de/hft/stuttgart/citydoctor2/edge/IntersectionErrorsTest.java

@@ -41,7 +41,7 @@ public class IntersectionErrorsTest {
 		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD);
 
 		ConcretePolygon p1 = new ConcretePolygon();
-
+		geom.addPolygon(p1);
 		LinearRing ext1 = new LinearRing(LinearRingType.EXTERIOR);
 		p1.setExteriorRing(ext1);
 		
@@ -66,6 +66,7 @@ public class IntersectionErrorsTest {
 		ext1.addVertex(v1);
 
 		ConcretePolygon p2 = new ConcretePolygon();
+		geom.addPolygon(p2);
 		LinearRing ext2 = new LinearRing(LinearRingType.EXTERIOR);
 		p2.setExteriorRing(ext2);
 
@@ -88,8 +89,8 @@ public class IntersectionErrorsTest {
 		ext2.addVertex(v8);
 		ext2.addVertex(v5);
 
-		geom.addPolygon(p1);
-		geom.addPolygon(p2);
+
+
 
 		geom.prepareForChecking();
 		

CityDoctorParent/CityDoctorModel/pom.xml

@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>de.hft.stuttgart</groupId>
 		<artifactId>CityDoctorParent</artifactId>
-		<version>3.18.1</version>
+		<version>3.18.2</version>
 	</parent>
 	<properties>
 		<versionString>${project.version}-${git.commit.id.abbrev}</versionString>

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/database/CityObjectCache.java

@@ -3,6 +3,7 @@ package de.hft.stuttgart.citydoctor2.database;
 import de.hft.stuttgart.citydoctor2.datastructure.CityObject;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 
+import java.util.Collection;
 import java.util.List;
 import java.util.stream.Stream;
 
@@ -21,6 +22,8 @@ public interface CityObjectCache {
      */
     CityObject get(GmlId id);
 
+
+    Collection<CityObject> getAll(List<GmlId> ids);
     /**
      * Replaces a CityObject with another one
      * @param id GmlID of the CityObject that is to be replaced

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/database/DatabaseCacheLoader.java

+package de.hft.stuttgart.citydoctor2.database;
+
+import com.github.benmanes.caffeine.cache.CacheLoader;
+import de.hft.stuttgart.citydoctor2.exceptions.EmbeddedDatabaseHandlerException;
+import org.jspecify.annotations.NonNull;
+
+import java.util.Map;
+import java.util.Set;
+
+public class DatabaseCacheLoader<K, V> implements CacheLoader<K, V> {
+
+    private final Unmarshaller<K, V> unmarshaller;
+    private final BatchUnmarshaller<K, V> batchUnmarshaller;
+
+    public DatabaseCacheLoader(Unmarshaller<K,V> unmarshaller, BatchUnmarshaller<K, V> batchUnmarshaller){
+        this.unmarshaller = unmarshaller;
+        this.batchUnmarshaller = batchUnmarshaller;
+    }
+
+    @Override
+    public @NonNull V load(@NonNull K key) throws EmbeddedDatabaseHandlerException {
+        return unmarshaller.unmarshall(key);
+    }
+
+    @Override
+    @NonNull
+    public Map<K, V> loadAll(@NonNull Set<? extends K> keys) throws EmbeddedDatabaseHandlerException {
+        return batchUnmarshaller.unmarshall(keys);
+    }
+
+    public interface Unmarshaller<K, V> {
+        V unmarshall(K key) throws EmbeddedDatabaseHandlerException;
+    }
+
+    public interface BatchUnmarshaller<K, V> {
+        Map<K, V> unmarshall(Set<? extends K> keys) throws EmbeddedDatabaseHandlerException;
+    }
+
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/database/DatabaseSettings.java

+package de.hft.stuttgart.citydoctor2.database;
+
+import de.hft.stuttgart.citydoctor2.exceptions.EmbeddedDatabaseHandlerException;
+import de.hft.stuttgart.citydoctor2.utils.Localization;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.nio.file.InvalidPathException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Properties;
+
+public final class DatabaseSettings {
+
+    private static final Logger logger = LogManager.getLogger(DatabaseSettings.class);
+
+    private static final Properties props = new Properties();
+
+    private DatabaseSettings() {}
+
+    static {
+
+        File propFile = new File("DBSettings.properties");
+        if (propFile.exists()) {
+            loadPropertiesFromFile(propFile);
+        }
+    }
+
+    public static void loadPropertiesFromFile(File file) throws EmbeddedDatabaseHandlerException {
+        try (BufferedReader bis = new BufferedReader(new FileReader(file))) {
+            props.load(bis);
+        } catch (IOException e) {
+            throw new EmbeddedDatabaseHandlerException(e);
+        }
+    }
+
+    public static void setDBLocation(String dbLocation) throws EmbeddedDatabaseHandlerException{
+        Path dbPath = Paths.get(dbLocation).toAbsolutePath();
+        File dbLocationFile = dbPath.toFile();
+        if (!dbLocationFile.isFile()) {
+            dbPath = dbPath.resolve("cd_db");
+        }
+        Path dbParentDirectoryPath = dbPath.getParent();
+        if (dbParentDirectoryPath.toFile().mkdirs()){
+                logger.trace("Created parent directories for database location");
+        }
+        if (!dbParentDirectoryPath.toFile().canWrite()) {
+            throw new EmbeddedDatabaseHandlerException("Missing write permissions for database location:" + dbLocation);
+        }
+        props.setProperty("database.name", dbPath.getFileName().toString());
+        props.setProperty("database.directory", dbParentDirectoryPath.toAbsolutePath().toString());
+    }
+
+    public static EmbeddedDatabaseConfiguration getConfig() {
+        EmbeddedDatabaseConfiguration defaultConfig = new EmbeddedDatabaseConfiguration();
+        if (props.isEmpty()) {
+            logger.trace("No database settings found or specified, using default config");
+            return defaultConfig;
+        }
+        String name = props.getProperty("database.name");
+        String directory = props.getProperty("database.directory");
+        String poolSizeString = props.getProperty("database.connectionPoolSize");
+        String inMemoryModeString = props.getProperty("database.inMemoryMode");
+        String attemptFallbackString = props.getProperty("database.attemptFallback");
+        String debugModeString = props.getProperty("database.debugMode");
+        String tempModeString = props.getProperty("database.tempMode");
+
+        boolean inMemoryMode = Boolean.parseBoolean(inMemoryModeString);
+        boolean attemptFallback = attemptFallbackString == null || Boolean.parseBoolean(attemptFallbackString);
+        boolean debugMode = Boolean.parseBoolean(debugModeString);
+        boolean tempMode = Boolean.parseBoolean(tempModeString);
+
+        int poolSize = defaultConfig.connectionPoolSize();
+        if (poolSizeString != null && !poolSizeString.isBlank()){
+            try {
+                int size = Integer.parseInt(poolSizeString);
+                if (size < 1) {
+                    logger.warn(Localization.getText("DatabaseSettings.poolSizeLessThanOne"));
+                } else poolSize = size;
+            } catch (NumberFormatException e) {
+                logger.warn(Localization.getText("DatabaseSettings.poolSizeNaN"));
+            }
+        }
+
+
+        if (name == null || name.isBlank()){
+            name = defaultConfig.databaseName();
+        }
+        if (directory == null || directory.isBlank()){
+            directory = defaultConfig.databaseDirectory();
+        }
+        try {
+            Paths.get(directory, name);
+        } catch (InvalidPathException e) {
+            if (!inMemoryMode) {
+                // Only warn if in-memory mode is not being used
+                logger.warn(Localization.getText("DatabaseSettings.invalidPath"));
+                name = defaultConfig.databaseName();
+                directory = defaultConfig.databaseDirectory();
+            }
+        }
+
+        return new EmbeddedDatabaseConfiguration(name, directory, poolSize, inMemoryMode, attemptFallback, debugMode, tempMode);
+    }
+
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/database/EmbeddedDatabaseConfiguration.java

+package de.hft.stuttgart.citydoctor2.database;
+
+import java.io.File;
+import java.nio.file.Paths;
+import java.util.StringJoiner;
+
+/**
+ * Record containing the configuration parameters for the setup of the embedded database
+ * @param databaseName Name of the database
+ * @param databaseDirectory Directory of the database. Relative paths will be resolved from the current working directory.
+ *                          CityDoctor will create the directory if it does not exist, and will overwrite an existing
+ *                          database-file if its name matches databaseName
+ * @param connectionPoolSize Size of the connection pool
+ * @param inMemoryMode If true, CityDoctor will create the embedded database in RAM
+ * @param attemptFallback If true, CityDoctor will attempt to create the embedded database in RAM if creation of the
+ *                        database-file fails. Will be ignored if inMemoryMode is true
+ * @param debugMode If true, CityDoctor will start the embedded database in automatic mixed mode to allow access to the
+ *                  database during runtime.
+ * @param tempFileMode If true, CityDoctor will create the database in the system's temp directory. Will be ignored if
+ *                     inMemoryMode is true
+ */
+public record EmbeddedDatabaseConfiguration(String databaseName, String databaseDirectory, int connectionPoolSize,
+                                            boolean inMemoryMode, boolean attemptFallback, boolean debugMode, boolean tempFileMode) {
+
+    private static final String IN_MEMORY_PREFIX = "mem:";
+    private static final String JDBC_DRIVER_PREFIX = "jdbc:h2:";
+    private static final String AUTO_SERVER_PARAMETER = "AUTO_SERVER=TRUE";
+    private static final String KEEP_ALIVE_PARAMETER = "DB_CLOSE_DELAY=-1";
+    /**
+     * Instantiates the default configuration for the embedded database.
+     */
+    EmbeddedDatabaseConfiguration() {
+        this("cd_db", File.separator + "database"+ File.separator, Runtime.getRuntime().availableProcessors(),
+                false, true, false, false);
+    }
+
+    public static EmbeddedDatabaseConfiguration getTestConfig() {
+        return new EmbeddedDatabaseConfiguration("cd_db", File.separator + "database"+ File.separator, Runtime.getRuntime().availableProcessors(),
+                true, true, true, false);
+    }
+
+    public String wrapUrlWithH2JdbcDriver(String url){
+        return JDBC_DRIVER_PREFIX + url + getH2ParametersSuffix();
+    }
+
+    public String getInMemoryH2Url() {
+        return wrapUrlWithH2JdbcDriver(IN_MEMORY_PREFIX + databaseName);
+    }
+
+    public String getFallbackH2Url(){
+        return getInMemoryH2Url() + ";" + KEEP_ALIVE_PARAMETER;
+    }
+
+    public String getH2FileUrl(){
+        return wrapUrlWithH2JdbcDriver(Paths.get(databaseDirectory).resolve(databaseName).toString());
+    }
+
+    public String getH2ParametersSuffix(){
+        StringJoiner joiner  = new StringJoiner(";",";","");
+        if (debugMode){
+            joiner.add(AUTO_SERVER_PARAMETER);
+        }
+        if (inMemoryMode){
+            joiner.add(KEEP_ALIVE_PARAMETER);
+        }
+        return joiner.toString();
+    }
+
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/database/EmbeddedDatabaseHandler.java

@@ -8,25 +8,34 @@ import de.hft.stuttgart.citydoctor2.datastructure.CityObject;
 import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 
+import de.hft.stuttgart.citydoctor2.exceptions.EmbeddedDatabaseHandlerException;
 import de.hft.stuttgart.citydoctor2.utils.Localization;
 import org.apache.commons.lang3.SerializationException;
 import org.apache.commons.lang3.SerializationUtils;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.h2gis.functions.factory.H2GISDBFactory;
 import org.h2gis.utilities.wrapper.DataSourceWrapper;
+import org.h2gis.functions.factory.H2GISFunctions;
 
 import java.io.ByteArrayInputStream;
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InvalidClassException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.sql.Array;
 import java.sql.Connection;
+import java.sql.DriverManager;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
 
 /**
  * Utility class for setup and access of the embedded database.
@@ -34,34 +43,71 @@ import java.util.Map;
 public class EmbeddedDatabaseHandler {
 
     private static final Logger logger = LogManager.getLogger(EmbeddedDatabaseHandler.class);
-    private static final String DB_NAME = "/database/cd_db";
+    private final EmbeddedDatabaseConfiguration config;
     private DataSourceWrapper dataSource;
+    private File tempFileDBLocation = null;
 
-    public EmbeddedDatabaseHandler(){
+    public EmbeddedDatabaseHandler(EmbeddedDatabaseConfiguration dbConfig){
+        config = dbConfig;
+        String jdbcUrl;
         try {
-            String jdbcurl = H2GISDBFactory.createDataSource(DB_NAME,
-                    true, ";").getConnection().getMetaData().getURL();
+            if (config.inMemoryMode()) {
+                jdbcUrl = createEmbeddedDataBase(config.getInMemoryH2Url());
+            } else if (config.tempFileMode()){
+                Path tmpDir = Files.createTempDirectory(config.databaseDirectory());
+                tmpDir.toFile().deleteOnExit();
+                String tempFileUrl = tmpDir.resolve(config.databaseName()).toFile().getCanonicalPath();
+                jdbcUrl = createEmbeddedDataBase(config.wrapUrlWithH2JdbcDriver(tempFileUrl));
+                tempFileDBLocation = new File(tempFileUrl+".mv.db");
+                tempFileDBLocation.deleteOnExit();
+            } else {
+                jdbcUrl = createEmbeddedDataBase(config.getH2FileUrl());
+            }
+            logger.debug("1] {}",jdbcUrl);
 
-            logger.debug("1] {}",jdbcurl);
-            HikariDataSource ds = new HikariDataSource();
+        } catch (Exception e) {
+            logger.fatal(Localization.getText("DatabaseHandler.setupFailure"));
+            logger.fatal(e.getMessage());
+            if (config.attemptFallback()){
+                logger.info("Attempting fallback to in-memory database");
+                try {
+                    jdbcUrl = createEmbeddedDataBase(config.getFallbackH2Url());
+                } catch (Exception e1) {
+                    throw new EmbeddedDatabaseHandlerException("Fallback to in-memory database failed, embedded database could not be created", e1);
+                }
+                logger.info("Fallback to in-memory database succeeded");
+                logger.warn("The in-memory database is limited by the system's available RAM. Loading big CityGML files can lead to OutOfMemory errors.");
+            } else {
+                throw new EmbeddedDatabaseHandlerException("Embedded database could not be created");
+            }
 
-            ds.setJdbcUrl(jdbcurl);
+        }
+        setupHikariPool(jdbcUrl);
+        setupFeaturesTable();
+    }
+
+    private void setupHikariPool(String jdbcUrl){
+        HikariDataSource ds = new HikariDataSource();
+        ds.setJdbcUrl(jdbcUrl);
         ds.setUsername("sa");
         ds.setPassword("sa");
-            int coreCount = Runtime.getRuntime().availableProcessors();
-            ds.setMaximumPoolSize(coreCount*5);
-            ds.setMinimumIdle(coreCount*5);
-
+        ds.setMaximumPoolSize(config.connectionPoolSize());
         dataSource = new DataSourceWrapper(ds);
-            setupFeaturesTable();
         //Cleanup hook
         Runtime.getRuntime().addShutdownHook(new Thread(ds::close));
-        } catch (Exception e) {
-            logger.fatal(Localization.getText("DatabaseHandler.setupFailure"));
-            logger.fatal(e.getMessage());
     }
 
+    // Embedded database can only ever be accessed by the local machine, suppress linter-warning about password leak
+    @SuppressWarnings("java:S6437")
+    private String createEmbeddedDataBase(String dbUrl) throws SQLException {
+        try (Connection con = DriverManager.getConnection(dbUrl,"sa","sa")){
+            H2GISFunctions.load(con);
+            return con.getMetaData().getURL();
+        }
+    }
 
+    public File getTempFileDBLocation(){
+        return this.tempFileDBLocation;
     }
 
 
@@ -69,22 +115,26 @@ public class EmbeddedDatabaseHandler {
         try (Connection con = dataSource.getConnection()) {
             try (PreparedStatement dropPs = con.prepareStatement("DROP TABLE IF EXISTS features")){
                 dropPs.executeUpdate();
-                if (logger.isDebugEnabled()) {
-                    logger.debug("Dropped existing features table");
+                logger.trace("Dropped existing features table");
             }
+            try (PreparedStatement dropIndexPs = con.prepareStatement("DROP INDEX IF EXISTS FEATURES_SPATIAL_INDEX")){
+                dropIndexPs.executeUpdate();
+                logger.trace("Dropped existing spatial index");
             }
             try (PreparedStatement createPs = con.prepareStatement("CREATE TABLE features (gmlid VARCHAR(255)" +
                     " PRIMARY KEY, bbox GEOMETRY, data BLOB, errors BOOLEAN);")) {
                 createPs.executeUpdate();
-                if (logger.isDebugEnabled()) {
-                    logger.debug("Created features table");
+                logger.trace("Created features table");
             }
-                //CREATE SPATIAL INDEX GEO_TABLE_SPATIAL_INDEX ON GEO_TABLE(THE_GEOM); <- Create spatial id
+            try (PreparedStatement createIndexPs = con.prepareStatement("CREATE SPATIAL INDEX FEATURES_SPATIAL_INDEX ON features(bbox);")){
+                createIndexPs.executeUpdate();
+                logger.trace("Created spatial index");
             }
 
         } catch (SQLException e) {
             logger.fatal(Localization.getText("DatabaseHandler.tableFailure"));
             logger.fatal(e.getMessage());
+            throw new EmbeddedDatabaseHandlerException("Could not setup features table in database", e);
         }
     }
 
@@ -96,8 +146,7 @@ public class EmbeddedDatabaseHandler {
         try (Connection con = dataSource.getConnection()) {
             try (PreparedStatement ps = con.prepareStatement("MERGE INTO features VALUES (?, ?, ?, ?)")) {
                 ps.setString(1, co.getGmlId().toString());
-                String bbox = BoundingBox.of(co).to2DWkt();
-                ps.setString(2, bbox);
+                ps.setString(2, co.getBbox().to2DWkt());
                 ps.setBoolean(4, co.containsAnyError());
 
                 if (logger.isDebugEnabled()) {
@@ -198,7 +247,7 @@ public class EmbeddedDatabaseHandler {
                     }
                 }
             } catch (IOException e) {
-                throw new RuntimeException(e);
+                throw new EmbeddedDatabaseHandlerException(e);
             }
         } catch (SQLException e) {
             logger.error(Localization.getText("DatabaseHandler.unmarshallingFailure"), id);
@@ -208,6 +257,47 @@ public class EmbeddedDatabaseHandler {
         return null;
     }
 
+    public Map<GmlId, CityObject> unmarshallAllIds(Set<? extends GmlId> ids){
+        try (Connection con = dataSource.getConnection()) {
+            try (PreparedStatement ps = con.prepareStatement(
+                    "SELECT data FROM features WHERE ARRAY_CONTAINS(? ,gmlid)")) {
+                String[] idStrings = ids.stream().map(Objects::toString).toArray(String[]::new);
+                Array array = con.createArrayOf("VARCHAR(255)", idStrings);
+                ps.setArray(1, array);
+                ResultSet rs = ps.executeQuery();
+                boolean encounteredError = false;
+                Map<GmlId, CityObject> objects= new HashMap<>();
+                while (rs.next()) {
+                    try (InputStream is = rs.getBinaryStream("data")) {
+                        CityObject co =  SerializationUtils.deserialize(is);
+                        // Rebuild the adjacency maps
+                        co.accept(new CheckableUtilsVisitor() {
+                            @Override
+                            public void check(Geometry geom) {
+                                geom.updateVertices();
+                            }
+                        });
+                        objects.put(co.getGmlId(),co);
+                    } catch (InvalidClassException | ClassCastException | SerializationException e){
+                        //Cant get the id of the failed Feature, as the deserialization didn't work.
+                        encounteredError = true;
+                    }
+                }
+                if (encounteredError){
+                    logger.error("Deserialization of one or more Features failed");
+                }
+                return objects;
+            } catch (IOException e) {
+                throw new EmbeddedDatabaseHandlerException(e);
+            }
+        } catch (SQLException e) {
+            logger.error(Localization.getText("DatabaseHandler.unmarshallingFailure"), ids);
+            logger.error(e.getMessage());
+        }
+
+        return null;
+    }
+
     /**
      * Retrieves a List of GmlIds of CityObjects that contain any {@link de.hft.stuttgart.citydoctor2.check.CheckError CheckError}.
      * @return a List of GmlIds of CityObjects containing any CheckError

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/database/FeatureCache.java

@@ -8,7 +8,9 @@ import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
+import java.util.Collection;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -42,12 +44,18 @@ public class FeatureCache implements CityObjectCache{
     private final ConcurrentHashMap<Thread, GmlId> evictionLocks = new ConcurrentHashMap<>();
 
     public FeatureCache() {
-        handler = new EmbeddedDatabaseHandler();
+        this(DatabaseSettings.getConfig());
+    }
+
+    public FeatureCache(EmbeddedDatabaseConfiguration dbConfig){
+        handler = new EmbeddedDatabaseHandler(dbConfig);
+        DatabaseCacheLoader.Unmarshaller<GmlId, CityObject> single = handler::unmarshallCityObject;
+        DatabaseCacheLoader.BatchUnmarshaller<GmlId, CityObject> batch = handler::unmarshallAllIds;
         cache = Caffeine.newBuilder().maximumSize(3000).removalListener((GmlId key, CityObject value, RemovalCause cause) -> {
-                    if (value != null && cause.wasEvicted() && isFeatureMarshallable(value)){
+            if (cause.wasEvicted() && isFeatureMarshallable(value)){
                 handler.marshallCityObject(value);
             }
-        }).build(handler::unmarshallCityObject);
+        }).build(new DatabaseCacheLoader<>(single, batch));
     }
 
     /**
@@ -111,6 +119,11 @@ public class FeatureCache implements CityObjectCache{
         return cache.get(id);
     }
 
+    @Override
+    public Collection<CityObject> getAll(List<GmlId> ids){
+        Map<GmlId, CityObject> map = cache.getAll(new HashSet<>(ids));
+        return map.values();
+    }
 
 
     @Override

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/database/UnconnectedCache.java

@@ -5,6 +5,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.CityObject;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -37,6 +38,12 @@ public class UnconnectedCache implements CityObjectCache{
         return cache.get(id);
     }
 
+    @Override
+    public Collection<CityObject> getAll(List<GmlId> ids) {
+       return ids.stream().map(cache::get).toList();
+    }
+
+
     @Override
     public void replace(GmlId id, CityObject cityObject) {
         cache.put(id, cityObject);

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BoundingBox.java

@@ -22,6 +22,8 @@ import de.hft.stuttgart.citydoctor2.math.Vector3d;
 import de.hft.stuttgart.citydoctor2.utils.BoundingBoxCalculator;
 import de.hft.stuttgart.citydoctor2.utils.visitors.MinMaxExtentVisitor;
 
+import java.io.Serial;
+import java.io.Serializable;
 import java.util.Collection;
 import java.util.List;
 import java.util.Locale;
@@ -31,7 +33,10 @@ import java.util.Locale;
  *
  * @author Matthias Betz
  */
-public class BoundingBox {
+public class BoundingBox implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = 1998769586245522486L;
 
     private final Vector3d[] bbox;
 

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityObject.java

@@ -43,7 +43,7 @@ public abstract class CityObject extends GmlElement {
     @Serial
     private static final long serialVersionUID = 651712070755024188L;
 
-
+    private BoundingBox bbox;
     private final List<Geometry> geometryList = new ArrayList<>();
     private final List<GenericAttribute> genericAttributeList = new ArrayList<>();
 
@@ -88,6 +88,17 @@ public abstract class CityObject extends GmlElement {
         this.accept(new UnsetGeometriesVisitor());
     }
 
+    public void setBbox(BoundingBox bbox){
+        this.bbox = bbox;
+    }
+
+    public synchronized BoundingBox getBbox(){
+        if (bbox == null){
+            this.setBbox(BoundingBox.of(this));
+        }
+        return bbox;
+    }
+
     /**
      * Adds a Geometry to this object.
      * @param geom the Geometry to add.

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/GenericAttribute.java

@@ -9,6 +9,8 @@ import java.io.Serial;
 import java.io.Serializable;
 
 import java.util.List;
+import java.util.StringJoiner;
+import java.util.function.Supplier;
 
 
 public class GenericAttribute implements Serializable {
@@ -17,6 +19,7 @@ public class GenericAttribute implements Serializable {
     private static final long serialVersionUID = -4101408947632132328L;
 
     private static final Logger logger = LogManager.getLogger(GenericAttribute.class);
+    private static final String NULL_VALUE_STRING= "NULL OR INVALID VALUE";
 
     private final AbstractGenericAttributeProperty original;
 
@@ -24,6 +27,7 @@ public class GenericAttribute implements Serializable {
     private String name;
     private String value;
 
+
     public GenericAttribute(AbstractGenericAttributeProperty attributeProperty) {
         original = attributeProperty;
         if (attributeProperty.getObject() == null) {
@@ -34,40 +38,42 @@ public class GenericAttribute implements Serializable {
 
         if (attributeProperty.getObject() instanceof StringAttribute sa) {
             type = "StringAttribute";
-            value = String.format("\"%s\"", sa.getValue());
+            value = extractValue(() -> String.format("\"%s\"", sa.getValue()));
         } else if (attributeProperty.getObject() instanceof IntAttribute ia) {
             type = "IntAttribute";
-            value = ia.getValue().toString();
+            value = extractValue(() -> ia.getValue().toString());
         } else if (attributeProperty.getObject() instanceof DoubleAttribute da) {
             type = "DoubleAttribute";
-            value = da.getValue().toString();
+            value = extractValue(() -> da.getValue().toString());
         } else if (attributeProperty.getObject() instanceof DateAttribute date) {
             type = "DateAttribute";
-            value = date.getValue().toString();
+            value = extractValue(() -> date.getValue().toString());
         } else if (attributeProperty.getObject() instanceof UriAttribute ua) {
             type = "UriAttribute";
-            value = ua.getValue();
+            value = extractValue(ua::getValue);
         } else if (attributeProperty.getObject() instanceof MeasureAttribute ma) {
             type = "MeasureAttribute";
-            value = String.format("%s %s", ma.getValue().getValue().toString(), ma.getValue().getUom());
+            value = extractValue(() ->
+                    String.format("%s %s", ma.getValue().getValue().toString(), ma.getValue().getUom()));
         } else if (attributeProperty.getObject() instanceof CodeAttribute ca) {
             type = String.format("CodeAttribute (%s)", ca.getValue().getLanguage());
-            value = String.format("'''%s''' %n CodeSpace: %s", ca.getValue().getValue(), ca.getValue().getCodeSpace());
+            value = extractValue(() ->
+                    String.format("'''%s''' %n CodeSpace: %s", ca.getValue().getValue(), ca.getValue().getCodeSpace()));
         } else if (attributeProperty.getObject() instanceof GenericAttributeSet gas) {
             type = "GenericAttributeSet";
             List<AbstractGenericAttributeProperty> attributes = gas.getValue();
-            StringBuilder sb = new StringBuilder();
-            sb.append("{");
+            if(attributes == null || attributes.isEmpty()){
+                value = NULL_VALUE_STRING;
+                return;
+            }
+            StringJoiner sj = new StringJoiner("; ","{","}");
+            sj.setEmptyValue("EMPTY_SET");
             for (AbstractGenericAttributeProperty attribute : attributes) {
                 if (attribute.getObject() != null) {
-                    sb.append(attribute.getObject().getName());
-                    sb.append(" = ");
-                    sb.append(attribute.getObject().getValue());
-                    sb.append("; ");
+                    sj.add(String.format("%1$s = %2$s",attribute.getObject().getName(), attribute.getObject().getValue()));
                 }
             }
-            sb.replace(sb.length() - 1, sb.length(), "}");
-            value = String.format("'%s'", sb);
+            value = sj.toString();
 
         } else {
             logger.warn("GenericAttribute {} is of unknown type {}", attributeProperty, attributeProperty.getObject());
@@ -77,6 +83,14 @@ public class GenericAttribute implements Serializable {
 
     }
 
+    private String extractValue(Supplier<String> supply){
+        try{
+            return supply.get();
+        }catch (NullPointerException e){
+            return NULL_VALUE_STRING;
+        }
+    }
+
     public AbstractGenericAttributeProperty getOriginal() {
         return original;
     }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ImplicitGeometryHolder.java

@@ -61,6 +61,7 @@ public class ImplicitGeometryHolder extends Geometry {
         if(!deferredRelGeomObjects.isEmpty()) {
             logger.info("Resolving deferred relative geometries");
         }
+        Set<GmlId> changedFeatures = new HashSet<>();
         for (ImplicitGeometryHolder key : deferredRelGeomObjects.keySet()) {
             ImplicitGeometry ig = deferredRelGeomObjects.get(key);
             String hrefId = ig.getRelativeGeometry().getHref();
@@ -72,10 +73,15 @@ public class ImplicitGeometryHolder extends Geometry {
                 CityObject parent = cache.get(key.getParent().getGmlId());
                 parent.removeGeometry(igh.getLod(), igh.getType());
                 parent.addGeometry(igh);
+                changedFeatures.add(parent.getTopLevelCityObject().getGmlId());
             } else {
                 missingGeoms.add(gmlId);
             }
         }
+        changedFeatures.forEach(gmlId -> {
+          CityObject co = cache.get(gmlId);
+          co.setBbox(BoundingBox.of(co));
+        });
         if (!missingGeoms.isEmpty()) {
             logger.warn("RelativeGeometries of the following gmlIDs could not be resolved: {}", missingGeoms);
         }
@@ -113,31 +119,6 @@ public class ImplicitGeometryHolder extends Geometry {
         LibraryObject.resetObjectMap();
     }
 
-    /**
-     * Prepares the prototype geometries for checking and sets a lock to prevent clearing of metadata
-     */
-    public static void preparePrototypeGeometriesForChecking(){
-        RelativeGeometry.preparePrototypeGeometriesForChecking();
-        LibraryObject.preparePrototypeGeometriesForChecking();
-    }
-
-    /**
-     * Clears metadata creating for checking of prototype geometries and releases the metadata lock
-     */
-    public static void clearMetaDataOfPrototypeGeometries(){
-        RelativeGeometry.clearMetaDataOfPrototypeGeometries();
-        LibraryObject.clearMetaDataOfPrototypeGeometries();
-    }
-
-    @Override
-    public void accept(CheckableVisitor c) {
-        prototypeGeometry.accept(c);
-    }
-
-    @Override
-    public boolean isValidated() {
-        return prototypeGeometry.isValidated();
-    }
 
 
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LibraryObject.java

@@ -26,7 +26,6 @@ public class LibraryObject extends Geometry {
 	private static final Logger logger = LogManager.getLogger(LibraryObject.class);
 	@Serial
 	private static final long serialVersionUID = -50293435187454911L;
-    private static boolean metadataLocked = false;
 	private static final Map<String, LibraryObject> libraryObjects = new ConcurrentHashMap<>();
 
     public static LibraryObject of(Path path, ParserConfiguration config) {
@@ -79,33 +78,8 @@ public class LibraryObject extends Geometry {
         return objects.get(0).getHighestLodGeometry();
     }
 
-
     public static void resetObjectMap() {
         libraryObjects.clear();
     }
 
-    public static void preparePrototypeGeometriesForChecking() {
-        libraryObjects.values().forEach(LibraryObject::updateEdgesAndVertices);
-        metadataLocked = true;
-    }
-
-    public static void clearMetaDataOfPrototypeGeometries() {
-        metadataLocked = false;
-        libraryObjects.values().forEach(LibraryObject::clearMetaData);
-    }
-
-    @Override
-    public void updateEdgesAndVertices(){
-        if (!metadataLocked) {
-            super.updateEdgesAndVertices();
-        }
-    }
-
-    @Override
-    public void clearMetaData(){
-        if (!metadataLocked) {
-            super.clearMetaData();
-        }
-    }
-
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LinkedPolygon.java

@@ -19,8 +19,11 @@
 package de.hft.stuttgart.citydoctor2.datastructure;
 
 import de.hft.stuttgart.citydoctor2.check.Check;
+import de.hft.stuttgart.citydoctor2.check.CheckError;
 import de.hft.stuttgart.citydoctor2.check.CheckId;
 import de.hft.stuttgart.citydoctor2.check.CheckResult;
+import de.hft.stuttgart.citydoctor2.check.Checkable;
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
 import de.hft.stuttgart.citydoctor2.check.CheckableVisitor;
 import de.hft.stuttgart.citydoctor2.math.Vector3d;
 import de.hft.stuttgart.citydoctor2.tesselation.TesselatedPolygon;
@@ -62,6 +65,52 @@ public class LinkedPolygon extends Polygon {
         }
     }
 
+    @Override
+    public boolean hasExistingGmlId() {
+        return poly.hasExistingGmlId();
+    }
+
+    @Override
+    public void setValidated(boolean validated) {
+        // Linked polys themselves are not checked
+    }
+
+    @Override
+    public boolean isValidated() {
+        return poly.isValidated();
+    }
+
+    //TODO: Think how to handle this, as it violates class contract if ignored
+    @Override
+    public void prepareForChecking() {
+        // Linked polys themselves are not checked
+    }
+
+    @Override
+    public void clearMetaInformation() {
+        // Linked polys themselves are not checked
+    }
+
+    @Override
+    public boolean hasError(CheckId checkIdentifier) {
+        return poly.hasError(checkIdentifier);
+    }
+
+    @Override
+    public boolean hasAnyError() {
+        return poly.hasAnyError();
+    }
+
+    @Override
+    public void collectContainedErrors(List<CheckError> errors) {
+        poly.collectContainedErrors(errors);
+    }
+
+    @Override
+    public void collectErrors(List<CheckError> errors) {
+        poly.collectErrors(errors);
+    }
+
     @Override
     public CheckResult getCheckResult(Check c) {
         return poly.getCheckResult(c);
@@ -104,8 +153,12 @@ public class LinkedPolygon extends Polygon {
 
     @Override
     public void accept(CheckableVisitor c) {
-        // linked polygons are not checked
-        setValidated(true);
+        // LinkedPolygon should ignore Checks, as their referenced ConcretePolygon must be within the same TopLevelFeature.
+        // Checks always start iterating from a TopLevelFeature and thus will visit the referenced ConcretePolygon.
+        if (!c.isValidator()){
+            // Utility Visitors get passed to the ConcretePolygon, as they can start iterating from a sub-CityObject.
+            poly.accept(c);
+        }
     }
 
     @Override

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/RelativeGeometry.java

@@ -15,7 +15,6 @@ public class RelativeGeometry extends Geometry {
 	private static final long serialVersionUID = -686112245455298977L;
 
 	private static final Map<GmlId, RelativeGeometry> relativeGeometries = new ConcurrentHashMap<>();
-	private static boolean metadataLocked = false;
 
 	public static RelativeGeometry of(GmlId gmlId, Geometry geom) {
 		if (relativeGeometries.containsKey(gmlId)) {
@@ -40,27 +39,5 @@ public class RelativeGeometry extends Geometry {
 		relativeGeometries.clear();
 	}
 
-	public static void preparePrototypeGeometriesForChecking() {
-		relativeGeometries.values().forEach(RelativeGeometry::updateEdgesAndVertices);
-		metadataLocked = true;
-	}
-
-	public static void clearMetaDataOfPrototypeGeometries() {
-		metadataLocked = false;
-		relativeGeometries.values().forEach(RelativeGeometry::clearMetaData);
-	}
-
-	@Override
-	public void updateEdgesAndVertices(){
-		if (!metadataLocked) {
-			super.updateEdgesAndVertices();
-		}
-	}
 
-	@Override
-	public void clearMetaData(){
-		if (!metadataLocked) {
-			super.clearMetaData();
-		}
-	}
 }