Improving validation utils

CHANGELOG.md

@@ -22,6 +22,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Deleted parameter initFiles, set parameter append to false by default [#791](https://github.com/ie3-institute/PowerSystemDataModel/issues/791)
 - Use nio paths instead of strings for file path [#723](https://github.com/ie3-institute/PowerSystemDataModel/issues/723)
 - Data source will throw an exceptions instead of returning an empty optionals [#707](https://github.com/ie3-institute/PowerSystemDataModel/issues/707)
+- Improving `ValidationUtils` [#758](https://github.com/ie3-institute/PowerSystemDataModel/issues/758)
 
 
 ## [3.0.0] - 2023-02-16

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

@@ -0,0 +1,23 @@
+/*
+ * © 2023. TU Dortmund University,
+ * Institute of Energy Systems, Energy Efficiency and Energy Economics,
+ * Research group Distribution grid planning and operation
+*/
+package edu.ie3.datamodel.exceptions;
+
+import edu.ie3.datamodel.utils.ExceptionUtils;
+import java.util.List;
+
+public class FailedValidationException extends ValidationException {
+  public FailedValidationException(String message, Throwable throwable) {
+    super(message, throwable);
+  }
+
+  public FailedValidationException(String message) {
+    super(message);
+  }
+
+  public FailedValidationException(List<? extends Exception> exceptions) {
+    super("Validation failed due to: " + ExceptionUtils.getMessages(exceptions));
+  }
+}

src/main/java/edu/ie3/datamodel/utils/ExceptionUtils.java

@@ -13,7 +13,7 @@ private ExceptionUtils() {
   }
 
   /**
-   * Creates a string containing multiple exception messsages.
+   * Creates a string containing multiple exception messages.
    *
    * @param exceptions list of exceptions
    * @return str containing the messages

src/main/java/edu/ie3/datamodel/utils/Try.java

@@ -15,6 +15,7 @@
 import java.util.stream.Stream;
 
 public abstract class Try<T, E extends Exception> {
+  // fields
   private final T data;
   private final E exception;
   private final boolean isEmpty;
@@ -42,6 +43,8 @@ private Try(E ex) {
     isEmpty = true;
   }
 
+  // static utility methods
+
   /**
    * Method to create a {@link Try} object easily.
    *
@@ -75,7 +78,7 @@ public static <T, E extends Exception> Try<T, E> of(TrySupplier<T, E> supplier,
    */
   @SuppressWarnings("unchecked")
   public static <E extends Exception> Try<Void, E> ofVoid(
-      TrySupplier<?, E> supplier, Class<E> clazz) {
+      VoidSupplier<E> supplier, Class<E> clazz) {
     try {
       supplier.get();
       return Success.empty();
@@ -89,6 +92,96 @@ public static <E extends Exception> Try<Void, E> ofVoid(
     }
   }
 
+  /**
+   * Method to create a {@link Try} object easily.
+   *
+   * @param failure a {@link Failure} is returned.
+   * @param exception exception that should be wrapped by a {@link Failure}
+   * @return a {@link Try}
+   * @param <E> type of exception
+   */
+  public static <E extends Exception> Try<Void, E> ofVoid(boolean failure, E exception) {
+    if (failure) {
+      return Failure.ofVoid(exception);
+    } else {
+      return Success.empty();
+    }
+  }
+
+  /**
+   * Utility method to check a list of {@link VoidSupplier}'s.
+   *
+   * @param supplier list of {@link VoidSupplier}
+   * @param clazz class of the exception
+   * @return a list of {@link Try}
+   * @param <E> type of the exception
+   */
+  @SafeVarargs
+  public static <E extends Exception> List<Try<Void, E>> ofVoid(
+      Class<E> clazz, VoidSupplier<E>... supplier) {
+    return Arrays.stream(supplier).map(sup -> Try.ofVoid(sup, clazz)).toList();
+  }
+
+  /**
+   * Method to retrieve the exceptions from all {@link Failure} objects.
+   *
+   * @param tries collection of {@link Try} objects
+   * @return a list of {@link Exception}'s
+   */
+  public static <D, E extends Exception> List<E> getExceptions(
+      Collection<Try<? extends D, E>> tries) {
+    return tries.stream().filter(Try::isFailure).map(t -> ((Failure<?, E>) t).get()).toList();
+  }
+
+  /**
+   * Method to scan a collection of {@link Try} objects for {@link Failure}'s.
+   *
+   * @param c collection of {@link Try} objects
+   * @param typeOfData type of data
+   * @return a {@link Success} if no {@link Failure}'s are found in the collection
+   * @param <U> type of data
+   */
+  public static <U, E extends Exception> Try<Set<U>, FailureException> scanCollection(
+      Collection<Try<U, E>> c, Class<U> typeOfData) {
+    return scanStream(c.stream(), typeOfData.getSimpleName())
+        .transformS(stream -> stream.collect(Collectors.toSet()));
+  }
+
+  /**
+   * Method to scan a stream of {@link Try} objects for {@link Failure}'s.
+   *
+   * @param stream of {@link Try} objects
+   * @return a {@link Success} if no {@link Failure}'s are found in the stream
+   * @param <U> type of data
+   */
+  public static <U, E extends Exception> Try<Stream<U>, FailureException> scanStream(
+      Stream<Try<U, E>> stream, String typeOfData) {
+    Map<Boolean, List<Try<U, E>>> map = stream.collect(partitioningBy(Try::isSuccess));
+
+    List<Try<U, E>> successes = map.get(true);
+    List<Try<U, E>> failures = map.get(false);
+
+    // Both lists should exist in map per definition of partitioningBy
+    assert successes != null && failures != null;
+
+    if (!failures.isEmpty()) {
+      E first = failures.get(0).exception;
+
+      return new Failure<>(
+          new FailureException(
+              failures.size()
+                  + " exception(s) occurred within \""
+                  + typeOfData
+                  + "\" data, one is: "
+                  + first,
+              first.getCause()));
+    } else {
+      return new Success<>(successes.stream().map(t -> t.data));
+    }
+  }
+
+  // methods of try object
+
   /**
    * Returns true if this object is a {@link Success} or false if this object is a {@link Failure}.
    */
@@ -111,7 +204,7 @@ public boolean isEmpty() {
    * @throws E if this object is a {@link Failure}
    */
   public T getOrThrow() throws E {
-    if (data != null) {
+    if (isSuccess()) {
       return data;
     } else {
       assert exception != null;
@@ -223,66 +316,10 @@ public <U, R extends Exception> Try<U, R> transform(
     }
   }
 
-  /**
-   * Method to scan a collection of {@link Try} objects for {@link Failure}'s.
-   *
-   * @param c collection of {@link Try} objects
-   * @param typeOfData type of data
-   * @return a {@link Success} if no {@link Failure}'s are found in the collection
-   * @param <U> type of data
-   */
-  public static <U, E extends Exception> Try<Set<U>, FailureException> scanCollection(
-      Collection<Try<U, E>> c, Class<U> typeOfData) {
-    return scanStream(c.stream(), typeOfData.getSimpleName())
-        .transformS(stream -> stream.collect(Collectors.toSet()));
-  }
-
-  /**
-   * Method to scan a stream of {@link Try} objects for {@link Failure}'s.
-   *
-   * @param stream of {@link Try} objects
-   * @return a {@link Success} if no {@link Failure}'s are found in the stream
-   * @param <U> type of data
-   */
-  public static <U, E extends Exception> Try<Stream<U>, FailureException> scanStream(
-      Stream<Try<U, E>> stream, String typeOfData) {
-    Map<Boolean, List<Try<U, E>>> map = stream.collect(partitioningBy(Try::isSuccess));
-
-    List<Try<U, E>> successes = map.get(true);
-    List<Try<U, E>> failures = map.get(false);
-
-    // Both lists should exist in map per definition of partitioningBy
-    assert successes != null && failures != null;
-
-    if (!failures.isEmpty()) {
-      E first = failures.get(0).exception;
-
-      return new Failure<>(
-          new FailureException(
-              failures.size()
-                  + " exception(s) occurred within \""
-                  + typeOfData
-                  + "\" data, one is: "
-                  + first,
-              first.getCause()));
-    } else {
-      return new Success<>(successes.stream().map(t -> t.data));
-    }
-  }
-
-  /**
-   * Method to retrieve the exceptions from all {@link Failure} objects.
-   *
-   * @param tries collection of {@link Try} objects
-   * @return a list of {@link Exception}'s
-   */
-  public static <D, E extends Exception> List<E> getExceptions(
-      Collection<Try<? extends D, E>> tries) {
-    return tries.stream().filter(Try::isFailure).map(t -> ((Failure<?, E>) t).get()).toList();
-  }
-
   /** Implementation of {@link Try} class. This class is used to present a successful try. */
   public static final class Success<T, E extends Exception> extends Try<T, E> {
+    private static final Success<Void, ?> emptySuccess = new Success<>(null);
+
     public Success(T data) {
       super(data);
     }
@@ -307,8 +344,9 @@ public T get() {
      *
      * @param <E> type of exception
      */
+    @SuppressWarnings("unchecked")
     public static <E extends Exception> Success<Void, E> empty() {
-      return new Success<>(null);
+      return (Success<Void, E>) emptySuccess;
     }
   }
 
@@ -379,4 +417,14 @@ public static <T, U, E extends Exception> Failure<U, E> of(Failure<T, E> failure
   public interface TrySupplier<T, E extends Exception> {
     T get() throws E;
   }
+
+  /**
+   * Supplier for void methods to {@link Try} class.
+   *
+   * @param <E> type of exception that could be thrown
+   */
+  @FunctionalInterface
+  public interface VoidSupplier<E extends Exception> {
+    void get() throws E;
+  }
 }