Merge pull request #798 from ie3-institute/ms/#682-method-handleEntity-throws-Exception

Make ``handleEntity`` throw exceptions instead of returning empty optional

Author: sebastian-peter

src/main/java/edu/ie3/datamodel/exceptions/EntityProcessorException.java

@@ -9,7 +9,7 @@
  * Is thrown, when an something went wrong during entity field mapping creation in a {@link
  * edu.ie3.datamodel.io.processor.EntityProcessor}
  */
-public class EntityProcessorException extends RuntimeException {
+public class EntityProcessorException extends Exception {
   public EntityProcessorException(final String message, final Throwable cause) {
     super(message, cause);
   }

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

@@ -28,6 +28,7 @@ public abstract class Factory<C, D extends FactoryData, R> {
 
   private final List<Class<? extends C>> supportedClasses;
 
+  @SafeVarargs
   protected Factory(Class<? extends C>... supportedClasses) {
     this.supportedClasses = Arrays.asList(supportedClasses);
   }
@@ -54,9 +55,9 @@ public Try<R, FactoryException> get(D data) {
       validateParameters(data, allFields.toArray((IntFunction<Set<String>[]>) Set[]::new));
 
       // build the model
-      return new Success<>(buildModel(data));
+      return Success.of(buildModel(data));
     } catch (FactoryException e) {
-      return new Failure<>(
+      return Failure.of(
           new FactoryException(
               "An error occurred when creating instance of "
                   + data.getTargetClass().getSimpleName()

src/main/java/edu/ie3/datamodel/io/processor/EntityProcessor.java

@@ -8,6 +8,9 @@
 import edu.ie3.datamodel.exceptions.EntityProcessorException;
 import edu.ie3.datamodel.models.StandardUnits;
 import edu.ie3.datamodel.models.UniqueEntity;
+import edu.ie3.datamodel.utils.Try;
+import edu.ie3.datamodel.utils.Try.*;
+import edu.ie3.util.exceptions.QuantityException;
 import java.lang.reflect.Method;
 import java.util.*;
 import javax.measure.Quantity;
@@ -37,7 +40,7 @@ public abstract class EntityProcessor<T extends UniqueEntity> extends Processor<
    *
    * @param registeredClass the class the entity processor should be able to handle
    */
-  protected EntityProcessor(Class<? extends T> registeredClass) {
+  protected EntityProcessor(Class<? extends T> registeredClass) throws EntityProcessorException {
     super(registeredClass);
     this.fieldNameToMethod =
         mapFieldNameToGetter(registeredClass, Collections.singleton(NODE_INTERNAL));
@@ -51,7 +54,7 @@ protected EntityProcessor(Class<? extends T> registeredClass) {
    * @return an optional Map with fieldName to fieldValue or an empty optional if an error occurred
    *     during processing
    */
-  public Optional<LinkedHashMap<String, String>> handleEntity(T entity) {
+  public LinkedHashMap<String, String> handleEntity(T entity) throws EntityProcessorException {
     if (!registeredClass.equals(entity.getClass()))
       throw new EntityProcessorException(
           "Cannot process "
@@ -62,33 +65,32 @@ public Optional<LinkedHashMap<String, String>> handleEntity(T entity) {
               + entity.getClass().getSimpleName()
               + ".class!");
 
-    try {
-      return Optional.of(processObject(entity, fieldNameToMethod));
-    } catch (EntityProcessorException e) {
-      logger.error("Cannot process the entity{}.", entity, e);
-      return Optional.empty();
-    }
+    return processObject(entity, fieldNameToMethod);
   }
 
   @Override
-  protected Optional<String> handleProcessorSpecificQuantity(
+  protected Try<String, QuantityException> handleProcessorSpecificQuantity(
       Quantity<?> quantity, String fieldName) {
     return switch (fieldName) {
       case "energy", "eConsAnnual", "eStorage":
-        yield quantityValToOptionalString(
-            quantity.asType(Energy.class).to(StandardUnits.ENERGY_IN));
+        yield Success.of(
+            quantityValToOptionalString(quantity.asType(Energy.class).to(StandardUnits.ENERGY_IN)));
       case "q":
-        yield quantityValToOptionalString(
-            quantity.asType(Power.class).to(StandardUnits.REACTIVE_POWER_IN));
+        yield Success.of(
+            quantityValToOptionalString(
+                quantity.asType(Power.class).to(StandardUnits.REACTIVE_POWER_IN)));
       case "p", "pMax", "pOwn", "pThermal":
-        yield quantityValToOptionalString(
-            quantity.asType(Power.class).to(StandardUnits.ACTIVE_POWER_IN));
+        yield Success.of(
+            quantityValToOptionalString(
+                quantity.asType(Power.class).to(StandardUnits.ACTIVE_POWER_IN)));
       default:
-        log.error(
-            "Cannot process quantity with value '{}' for field with name {} in input entity processing!",
-            quantity,
-            fieldName);
-        yield Optional.empty();
+        yield Failure.of(
+            new QuantityException(
+                "Cannot process quantity with value '"
+                    + quantity
+                    + "' for field with name "
+                    + fieldName
+                    + " in input entity processing!"));
     };
   }
 

src/main/java/edu/ie3/datamodel/io/processor/Processor.java

@@ -17,6 +17,9 @@
 import edu.ie3.datamodel.models.input.system.characteristic.CharacteristicInput;
 import edu.ie3.datamodel.models.profile.LoadProfile;
 import edu.ie3.datamodel.models.voltagelevels.VoltageLevel;
+import edu.ie3.datamodel.utils.Try;
+import edu.ie3.datamodel.utils.Try.*;
+import edu.ie3.util.exceptions.QuantityException;
 import java.beans.Introspector;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
@@ -72,7 +75,7 @@ public abstract class Processor<T> {
    *
    * @param foreSeenClass Class and its children that are foreseen to be handled with this processor
    */
-  protected Processor(Class<? extends T> foreSeenClass) {
+  protected Processor(Class<? extends T> foreSeenClass) throws EntityProcessorException {
     if (!getEligibleEntityClasses().contains(foreSeenClass))
       throw new EntityProcessorException(
           "Cannot register class '"
@@ -104,9 +107,10 @@ public int compare(String a, String b) {
    * Maps the foreseen table fields to the objects getters
    *
    * @param cls class to use for mapping
-   * @return an array of strings of all field values of the class
+   * @return a map of all field values of the class
    */
-  protected SortedMap<String, Method> mapFieldNameToGetter(Class<?> cls) {
+  protected SortedMap<String, Method> mapFieldNameToGetter(Class<?> cls)
+      throws EntityProcessorException {
     return mapFieldNameToGetter(cls, Collections.emptyList());
   }
 
@@ -115,10 +119,10 @@ protected SortedMap<String, Method> mapFieldNameToGetter(Class<?> cls) {
    *
    * @param cls class to use for mapping
    * @param ignoreFields A collection of all field names to ignore during process
-   * @return an array of strings of all field values of the class
+   * @return a map of all field values of the class
    */
   protected SortedMap<String, Method> mapFieldNameToGetter(
-      Class<?> cls, Collection<String> ignoreFields) {
+      Class<?> cls, Collection<String> ignoreFields) throws EntityProcessorException {
     try {
       final LinkedHashMap<String, Method> resFieldNameToMethod = new LinkedHashMap<>();
       Arrays.stream(Introspector.getBeanInfo(cls, Object.class).getPropertyDescriptors())
@@ -178,7 +182,7 @@ public static <V> SortedMap<String, V> putUuidFirst(Map<String, V> unsorted) {
    * @return Mapping from field name to value as String representation
    */
   protected LinkedHashMap<String, String> processObject(
-      Object object, Map<String, Method> fieldNameToGetter) {
+      Object object, Map<String, Method> fieldNameToGetter) throws EntityProcessorException {
     try {
       LinkedHashMap<String, String> resultMap = new LinkedHashMap<>();
       for (Map.Entry<String, Method> entry : fieldNameToGetter.entrySet()) {
@@ -207,7 +211,8 @@ protected LinkedHashMap<String, String> processObject(
    * @param fieldName Name of the foreseen field
    * @return A String representation of the result
    */
-  protected String processMethodResult(Object methodReturnObject, Method method, String fieldName) {
+  protected String processMethodResult(Object methodReturnObject, Method method, String fieldName)
+      throws EntityProcessorException {
 
     StringBuilder resultStringBuilder = new StringBuilder();
 
@@ -232,15 +237,19 @@ protected String processMethodResult(Object methodReturnObject, Method method, S
               .map(
                   o -> {
                     if (o instanceof Quantity<?>) {
-                      return handleQuantity((Quantity<?>) o, fieldName);
+                      return Try.of(
+                          () -> handleQuantity((Quantity<?>) o, fieldName),
+                          EntityProcessorException.class);
                     } else {
-                      throw new EntityProcessorException(
-                          "Handling of "
-                              + o.getClass().getSimpleName()
-                              + ".class instance wrapped into Optional is currently not supported by entity processors!");
+                      return Failure.of(
+                          new EntityProcessorException(
+                              "Handling of "
+                                  + o.getClass().getSimpleName()
+                                  + ".class instance wrapped into Optional is currently not supported by entity processors!"));
                     }
                   })
-              .orElse(""));
+              .orElse(Success.of("")) // (in case of empty optional)
+              .getOrThrow());
       case "ZonedDateTime" -> resultStringBuilder.append(
           processZonedDateTime((ZonedDateTime) methodReturnObject));
       case "OperationTime" -> resultStringBuilder.append(
@@ -306,7 +315,8 @@ protected String processMethodResult(Object methodReturnObject, Method method, S
    * @return the resulting string of a VoltageLevel attribute value for the provided field or an
    *     empty string when an invalid field name is provided
    */
-  protected String processVoltageLevel(VoltageLevel voltageLevel, String fieldName) {
+  protected String processVoltageLevel(VoltageLevel voltageLevel, String fieldName)
+      throws EntityProcessorException {
 
     StringBuilder resultStringBuilder = new StringBuilder();
     if (fieldName.equalsIgnoreCase(VOLT_LVL)) resultStringBuilder.append(voltageLevel.getId());
@@ -324,21 +334,26 @@ protected String processVoltageLevel(VoltageLevel voltageLevel, String fieldName
    * @return an optional string with the normalized to {@link StandardUnits} value of the quantity
    *     or empty if an error occurred during processing
    */
-  protected String handleQuantity(Quantity<?> quantity, String fieldName) {
-    Optional<String> optQuant;
+  protected String handleQuantity(Quantity<?> quantity, String fieldName)
+      throws EntityProcessorException {
+    Try<String, QuantityException> optQuant;
     if (specificQuantityFieldNames.contains(fieldName)) {
       optQuant = handleProcessorSpecificQuantity(quantity, fieldName);
     } else {
-      optQuant = quantityValToOptionalString(quantity);
+      optQuant = Success.of(quantityValToOptionalString(quantity));
     }
-    return optQuant.orElseThrow(
-        () ->
-            new EntityProcessorException(
-                "Unable to process quantity value for attribute '"
-                    + fieldName
-                    + "' in entity "
-                    + getRegisteredClass().getSimpleName()
-                    + ".class."));
+
+    return optQuant
+        .transformF(
+            e ->
+                new EntityProcessorException(
+                    "Unable to process quantity value for attribute '"
+                        + fieldName
+                        + "' in entity "
+                        + getRegisteredClass().getSimpleName()
+                        + ".class.",
+                    e))
+        .getOrThrow();
   }
 
   /**
@@ -354,7 +369,7 @@ protected String handleQuantity(Quantity<?> quantity, String fieldName) {
    * @return an optional string with the normalized to {@link StandardUnits} value of the quantity
    *     or empty if an error occurred during processing
    */
-  protected abstract Optional<String> handleProcessorSpecificQuantity(
+  protected abstract Try<String, QuantityException> handleProcessorSpecificQuantity(
       Quantity<?> quantity, String fieldName);
 
   protected String processUUIDArray(UUID[] uuids) {
@@ -406,8 +421,8 @@ protected String processZonedDateTime(ZonedDateTime zonedDateTime) {
    * @param quantity Quantity to convert
    * @return A string of the quantity's value
    */
-  protected Optional<String> quantityValToOptionalString(Quantity<?> quantity) {
-    return Optional.of(Double.toString(quantity.getValue().doubleValue()));
+  protected String quantityValToOptionalString(Quantity<?> quantity) {
+    return Double.toString(quantity.getValue().doubleValue());
   }
 
   /**