Use pattern matching

CHANGELOG.md

@@ -10,7 +10,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 - Reduced code smells
-- Protected constructors for abstract classes
+  - Protected constructors for abstract classes
+  - Use pattern matching
 
 ### Added
 - added `EvcsLocationType` support in `EvcsInput` and `EvcsInputFactory` [#406](https://github.com/ie3-institute/PowerSystemDataModel/issues/406)

gradle/scripts/spotless.gradle

@@ -33,7 +33,7 @@ spotless {
 
 	// removes unnecessary whitespace, indents with tabs and ends on new line for gradle, md and gitignore files and config-XMLs
 	format 'misc', {
-		target '**/*.md', '**/.gitignore', 'configs/**'
+		target '**/.gitignore', 'configs/**'
 		trimTrailingWhitespace()
 		indentWithTabs()
 		endWithNewline()

src/main/java/edu/ie3/datamodel/io/extractor/Extractor.java

@@ -33,23 +33,23 @@ private Extractor() {
   public static Set<InputEntity> extractElements(NestedEntity nestedEntity)
       throws ExtractorException {
     CopyOnWriteArrayList<InputEntity> resultingList = new CopyOnWriteArrayList<>();
-    if (nestedEntity instanceof HasNodes) {
-      resultingList.addAll(((HasNodes) nestedEntity).allNodes());
+    if (nestedEntity instanceof HasNodes nestedHasNode) {
+      resultingList.addAll((nestedHasNode).allNodes());
     }
-    if (nestedEntity instanceof Operable) {
-      extractOperator((Operable) nestedEntity).ifPresent(resultingList::add);
+    if (nestedEntity instanceof Operable nestedOperable) {
+      extractOperator(nestedOperable).ifPresent(resultingList::add);
     }
-    if (nestedEntity instanceof HasType) {
-      resultingList.add(extractType((HasType) nestedEntity));
+    if (nestedEntity instanceof HasType nestedHasType) {
+      resultingList.add(extractType(nestedHasType));
     }
-    if (nestedEntity instanceof HasThermalBus) {
-      resultingList.add(((HasThermalBus) nestedEntity).getThermalBus());
+    if (nestedEntity instanceof HasThermalBus nestedHasThermalBus) {
+      resultingList.add((nestedHasThermalBus).getThermalBus());
     }
-    if (nestedEntity instanceof HasThermalStorage) {
-      resultingList.add(((HasThermalStorage) nestedEntity).getThermalStorage());
+    if (nestedEntity instanceof HasThermalStorage nestedHasThermalStorage) {
+      resultingList.add((nestedHasThermalStorage).getThermalStorage());
     }
-    if (nestedEntity instanceof HasLine) {
-      resultingList.add(((HasLine) nestedEntity).getLine());
+    if (nestedEntity instanceof HasLine nestedHasLine) {
+      resultingList.add((nestedHasLine).getLine());
     }
 
     if (resultingList.contains(null)) {
@@ -72,9 +72,9 @@ public static Set<InputEntity> extractElements(NestedEntity nestedEntity)
         .parallel()
         .forEach(
             element -> {
-              if (element instanceof NestedEntity) {
+              if (element instanceof NestedEntity nestedElement) {
                 try {
-                  resultingList.addAll(extractElements((NestedEntity) element));
+                  resultingList.addAll(extractElements(nestedElement));
                 } catch (ExtractorException e) {
                   log.error(
                       "An error occurred during extraction of nested entity '{}':{}",
@@ -84,7 +84,7 @@ public static Set<InputEntity> extractElements(NestedEntity nestedEntity)
               }
             });
 
-    return Collections.unmodifiableSet(new HashSet<>(resultingList));
+    return Set.copyOf(resultingList);
   }
 
   public static AssetTypeInput extractType(HasType entityWithType) {

src/main/java/edu/ie3/datamodel/io/factory/EntityData.java

@@ -97,7 +97,7 @@ private Optional<Geometry> getGeometry(String field) {
   public Optional<LineString> getLineString(String field) {
     Optional<Geometry> geom = getGeometry(field);
     if (geom.isPresent()) {
-      if (geom.get() instanceof LineString) return Optional.of((LineString) geom.get());
+      if (geom.get() instanceof LineString lineString) return Optional.of(lineString);
       else
         throw new FactoryException(
             "Geometry is of type "
@@ -116,7 +116,7 @@ public Optional<LineString> getLineString(String field) {
   public Optional<Point> getPoint(String field) {
     Optional<Geometry> geom = getGeometry(field);
     if (geom.isPresent()) {
-      if (geom.get() instanceof Point) return Optional.of((Point) geom.get());
+      if (geom.get() instanceof Point point) return Optional.of(point);
       else
         throw new FactoryException(
             "Geometry is of type "

src/main/java/edu/ie3/datamodel/io/naming/EntityPersistenceNamingStrategy.java

@@ -336,8 +336,7 @@ Optional<String> getEntityName(T timeSeries) {
         logger.error("Unable to determine content of time series {}", timeSeries);
         return Optional.empty();
       }
-    } else if (timeSeries instanceof LoadProfileInput) {
-      LoadProfileInput loadProfileInput = (LoadProfileInput) timeSeries;
+    } else if (timeSeries instanceof LoadProfileInput loadProfileInput) {
       return Optional.of(
           prefix
               .concat("lpts")

src/main/java/edu/ie3/datamodel/io/processor/timeseries/TimeSeriesProcessor.java

@@ -235,9 +235,7 @@ private Map<String, String> handleEntry(T timeSeries, E entry) {
     Map<String, Method> valueFieldToMethod = extractFieldToMethod(VALUE);
     LinkedHashMap<String, String> valueResult = processObject(entry.getValue(), valueFieldToMethod);
     /* Treat WeatherValues specially, as they are nested ones */
-    if (entry.getValue() instanceof WeatherValue) {
-      WeatherValue weatherValue = (WeatherValue) entry.getValue();
-
+    if (entry.getValue() instanceof WeatherValue weatherValue) {
       Map<String, Method> irradianceFieldToMethod = extractFieldToMethod(WEATHER_IRRADIANCE);
       valueResult.putAll(processObject(weatherValue.getSolarIrradiance(), irradianceFieldToMethod));
 

src/main/java/edu/ie3/datamodel/io/sink/CsvFileSink.java

@@ -126,8 +126,7 @@ public <T extends UniqueEntity> void persist(T entity) {
       persistIncludeNested((InputEntity) entity);
     } else if (entity instanceof ResultEntity) {
       write(entity);
-    } else if (entity instanceof TimeSeries) {
-      TimeSeries<?, ?> timeSeries = (TimeSeries<?, ?>) entity;
+    } else if (entity instanceof TimeSeries<?, ?> timeSeries) {
       persistTimeSeries(timeSeries);
     } else {
       log.error(
@@ -147,10 +146,10 @@ public <C extends InputEntity> void persistAllIgnoreNested(Collection<C> entitie
 
   @Override
   public <C extends InputEntity> void persistIncludeNested(C entity) {
-    if (entity instanceof NestedEntity) {
+    if (entity instanceof NestedEntity nestedEntity) {
       try {
         write(entity);
-        for (InputEntity ent : Extractor.extractElements((NestedEntity) entity)) {
+        for (InputEntity ent : Extractor.extractElements(nestedEntity)) {
           write(ent);
         }
       } catch (ExtractorException e) {

src/main/java/edu/ie3/datamodel/io/sink/InfluxDbSink.java

@@ -236,19 +236,18 @@ private <E extends TimeSeriesEntry<V>, V extends Value> Set<Point> transformToPo
   private <C extends UniqueEntity> Set<Point> extractPoints(C entity) {
     Set<Point> points = new HashSet<>();
     /* Distinguish between result models and time series */
-    if (entity instanceof ResultEntity) {
+    if (entity instanceof ResultEntity resultEntity) {
       try {
         points.add(
-            transformToPoint((ResultEntity) entity)
+            transformToPoint(resultEntity)
                 .orElseThrow(() -> new SinkException("Could not transform entity")));
       } catch (SinkException e) {
         log.error(
             "Cannot persist provided entity '{}'. Exception: {}",
             entity.getClass().getSimpleName(),
             e);
       }
-    } else if (entity instanceof TimeSeries) {
-      TimeSeries<?, ?> timeSeries = (TimeSeries<?, ?>) entity;
+    } else if (entity instanceof TimeSeries<?, ?> timeSeries) {
       points.addAll(transformToPoints(timeSeries));
     } else {
       log.error(