Multiple active operational limits group

iidm/iidm-api/src/main/java/com/powsybl/iidm/network/Branch.java

@@ -9,6 +9,8 @@
 
 import java.util.Collection;
 import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import static com.powsybl.iidm.network.util.LoadingLimitsUtil.initializeFromLoadingLimits;
 
@@ -141,6 +143,12 @@ public interface Branch<I extends Branch<I>> extends Identifiable<I> {
      */
     Optional<OperationalLimitsGroup> getSelectedOperationalLimitsGroup1();
 
+    /**
+     * Get all the selected {@link OperationalLimitsGroup} on side 1.
+     * @return all the selected {@link OperationalLimitsGroup} on side 1, might be empty if none is selected
+     */
+    Collection<OperationalLimitsGroup> getAllSelectedOperationalLimitsGroup1();
+
     /**
      * <p>Create a new {@link OperationalLimitsGroup} on side 1 with the given ID.</p>
      * <p>If a group of the given ID already exists, it is replaced silently.</p>
@@ -178,6 +186,14 @@ default Optional<CurrentLimits> getCurrentLimits1() {
         return getSelectedOperationalLimitsGroup1().flatMap(OperationalLimitsGroup::getCurrentLimits);
     }
 
+    /**
+     * Get all the {@link CurrentLimits} of all the selected {@link OperationalLimitsGroup} on side 1.
+     * @return a collection of {@link CurrentLimits} for all the selected {@link OperationalLimitsGroup} on side 1, might be empty if none is selected
+     */
+    default Collection<CurrentLimits> getAllSelectedCurrentLimits1() {
+        return getAllSelectedLoadingLimits1(OperationalLimitsGroup::getCurrentLimits);
+    }
+
     /**
      * Get the {@link CurrentLimits} of the selected {@link OperationalLimitsGroup} on side 1.
      * @return {@link CurrentLimits} of the selected {@link OperationalLimitsGroup} on side 1 if any, <code>null</code> otherwise.
@@ -194,6 +210,14 @@ default Optional<ActivePowerLimits> getActivePowerLimits1() {
         return getSelectedOperationalLimitsGroup1().flatMap(OperationalLimitsGroup::getActivePowerLimits);
     }
 
+    /**
+     * Get all the {@link ActivePowerLimits} of all the selected {@link OperationalLimitsGroup} on side 1.
+     * @return a collection of {@link ActivePowerLimits} for all the selected {@link OperationalLimitsGroup} on side 1, might be empty if none is selected
+     */
+    default Collection<ActivePowerLimits> getAllSelectedActivePowerLimits1() {
+        return getAllSelectedLoadingLimits1(OperationalLimitsGroup::getActivePowerLimits);
+    }
+
     /**
      * Get the {@link ActivePowerLimits} of the selected {@link OperationalLimitsGroup} on side 1.
      * @return {@link ActivePowerLimits} of the selected {@link OperationalLimitsGroup} on side 1 if any, <code>null</code> otherwise.
@@ -210,6 +234,10 @@ default Optional<ApparentPowerLimits> getApparentPowerLimits1() {
         return getSelectedOperationalLimitsGroup1().flatMap(OperationalLimitsGroup::getApparentPowerLimits);
     }
 
+    default Collection<ApparentPowerLimits> getAllSelectedApparentPowerLimits1() {
+        return getAllSelectedLoadingLimits1(OperationalLimitsGroup::getApparentPowerLimits);
+    }
+
     /**
      * Get the {@link ApparentPowerLimits} of the selected {@link OperationalLimitsGroup} on side 1.
      * @return {@link ApparentPowerLimits} of the selected {@link OperationalLimitsGroup} on side 1 if any, <code>null</code> otherwise.
@@ -218,6 +246,20 @@ default ApparentPowerLimits getNullableApparentPowerLimits1() {
         return getApparentPowerLimits1().orElse(null);
     }
 
+    /**
+     * Helper function to return an operational limit of a given type using the provided function on the side one
+     * @param operationalLimitToLoadingLimitFunction the function that will return an optional {@link LoadingLimits} from an {@link OperationalLimitsGroup}
+     * @return a collection of loadingLimits, all the same type
+     * @param <T> the type of loadingLimit
+     */
+    private <T extends LoadingLimits> Collection<T> getAllSelectedLoadingLimits1(Function<OperationalLimitsGroup, Optional<T>> operationalLimitToLoadingLimitFunction) {
+        return getAllSelectedOperationalLimitsGroup1()
+                .stream()
+                .map(operationalLimitToLoadingLimitFunction)
+                .flatMap(Optional::stream)
+                .collect(Collectors.toList());
+    }
+
     /**
      * <p>Create an adder to add a new {@link CurrentLimits} in the selected {@link OperationalLimitsGroup} on side 1.</p>
      * <p>If there's no selected group, the adder will also create a new group with the default name and set it as selected.
@@ -358,6 +400,12 @@ default ApparentPowerLimitsAdder newApparentPowerLimits1(ApparentPowerLimits app
      */
     Optional<OperationalLimitsGroup> getSelectedOperationalLimitsGroup2();
 
+    /**
+     * Get all the selected {@link OperationalLimitsGroup} on side 2.
+     * @return all the selected {@link OperationalLimitsGroup} on side 2, might be empty if none is selected
+     */
+    Collection<OperationalLimitsGroup> getAllSelectedOperationalLimitsGroup2();
+
     /**
      * <p>Create a new {@link OperationalLimitsGroup} on side 2 with the given ID.</p>
      * <p>If a group of the given ID already exists, it is replaced silently.</p>
@@ -395,6 +443,14 @@ default Optional<CurrentLimits> getCurrentLimits2() {
         return getSelectedOperationalLimitsGroup2().flatMap(OperationalLimitsGroup::getCurrentLimits);
     }
 
+    /**
+     * Get all the {@link CurrentLimits} of all the selected {@link OperationalLimitsGroup} on side 2.
+     * @return a collection of {@link CurrentLimits} for all the selected {@link OperationalLimitsGroup} on side 2, might be empty if none is selected
+     */
+    default Collection<CurrentLimits> getAllSelectedCurrentLimits2() {
+        return getAllSelectedLoadingLimits2(OperationalLimitsGroup::getCurrentLimits);
+    }
+
     /**
      * Get the {@link CurrentLimits} of the selected {@link OperationalLimitsGroup} on side 2.
      * @return {@link CurrentLimits} of the selected {@link OperationalLimitsGroup} on side 2 if any, <code>null</code> otherwise.
@@ -411,6 +467,14 @@ default Optional<ActivePowerLimits> getActivePowerLimits2() {
         return getSelectedOperationalLimitsGroup2().flatMap(OperationalLimitsGroup::getActivePowerLimits);
     }
 
+    /**
+     * Get all the {@link ActivePowerLimits} of all the selected {@link OperationalLimitsGroup} on side 2.
+     * @return a collection of {@link ActivePowerLimits} for all the selected {@link OperationalLimitsGroup} on side 2, might be empty if none is selected
+     */
+    default Collection<ActivePowerLimits> getAllSelectedActivePowerLimits2() {
+        return getAllSelectedLoadingLimits2(OperationalLimitsGroup::getActivePowerLimits);
+    }
+
     /**
      * Get the {@link ActivePowerLimits} of the selected {@link OperationalLimitsGroup} on side 2.
      * @return {@link ActivePowerLimits} of the selected {@link OperationalLimitsGroup} on side 2 if any, <code>null</code> otherwise.
@@ -427,6 +491,10 @@ default Optional<ApparentPowerLimits> getApparentPowerLimits2() {
         return getSelectedOperationalLimitsGroup2().flatMap(OperationalLimitsGroup::getApparentPowerLimits);
     }
 
+    default Collection<ApparentPowerLimits> getAllSelectedApparentPowerLimits2() {
+        return getAllSelectedLoadingLimits2(OperationalLimitsGroup::getApparentPowerLimits);
+    }
+
     /**
      * Get the {@link ApparentPowerLimits} of the selected {@link OperationalLimitsGroup} on side 2.
      * @return {@link ApparentPowerLimits} of the selected {@link OperationalLimitsGroup} on side 2 if any, <code>null</code> otherwise.
@@ -435,6 +503,20 @@ default ApparentPowerLimits getNullableApparentPowerLimits2() {
         return getApparentPowerLimits2().orElse(null);
     }
 
+    /**
+     * Helper function to return an operational limit of a given type using the provided function on the side two
+     * @param operationalLimitToLoadingLimitFunction the function that will return an optional {@link LoadingLimits} from an {@link OperationalLimitsGroup}
+     * @return a collection of loadingLimits, all the same type
+     * @param <T> the type of loadingLimit
+     */
+    private <T extends LoadingLimits> Collection<T> getAllSelectedLoadingLimits2(Function<OperationalLimitsGroup, Optional<T>> operationalLimitToLoadingLimitFunction) {
+        return getAllSelectedOperationalLimitsGroup2()
+                .stream()
+                .map(operationalLimitToLoadingLimitFunction)
+                .flatMap(Optional::stream)
+                .collect(Collectors.toList());
+    }
+
     /**
      * <p>Create an adder to add a new {@link CurrentLimits} in the selected {@link OperationalLimitsGroup} on side 2.</p>
      * <p>If there's no selected group, the adder will also create a new group with the default name and set it as selected.
@@ -521,20 +603,42 @@ default Optional<CurrentLimits> getCurrentLimits(TwoSides side) {
         };
     }
 
+    default Collection<CurrentLimits> getAllSelectedCurrentLimits(TwoSides side) {
+        return switch (side) {
+            case ONE -> getAllSelectedCurrentLimits1();
+            case TWO -> getAllSelectedCurrentLimits2();
+        };
+    }
+
     default Optional<ActivePowerLimits> getActivePowerLimits(TwoSides side) {
         return switch (side) {
             case ONE -> getActivePowerLimits1();
             case TWO -> getActivePowerLimits2();
         };
     }
 
+    default Collection<ActivePowerLimits> getAllSelectedActivePowerLimits(TwoSides side) {
+        return switch (side) {
+            case ONE -> getAllSelectedActivePowerLimits1();
+            case TWO -> getAllSelectedActivePowerLimits2();
+        };
+    }
+
     default Optional<ApparentPowerLimits> getApparentPowerLimits(TwoSides side) {
         return switch (side) {
             case ONE -> getApparentPowerLimits1();
             case TWO -> getApparentPowerLimits2();
         };
     }
 
+    default Collection<ApparentPowerLimits> getAllSelectedApparentPowerLimits(TwoSides side) {
+        return switch (side) {
+            case ONE -> getAllSelectedApparentPowerLimits1();
+            case TWO -> getAllSelectedApparentPowerLimits2();
+        };
+    }
+
+    //TODO deprecate this ?
     default Optional<? extends LoadingLimits> getLimits(LimitType type, TwoSides side) {
         return switch (type) {
             case CURRENT -> getCurrentLimits(side);
@@ -545,6 +649,16 @@ default Optional<? extends LoadingLimits> getLimits(LimitType type, TwoSides sid
         };
     }
 
+    default Collection<? extends LoadingLimits> getAllSelectedLimits(LimitType type, TwoSides side) {
+        return switch (type) {
+            case CURRENT -> getAllSelectedCurrentLimits(side);
+            case ACTIVE_POWER -> getAllSelectedActivePowerLimits(side);
+            case APPARENT_POWER -> getAllSelectedApparentPowerLimits(side);
+            default ->
+                    throw new UnsupportedOperationException(String.format("Getting %s limits is not supported.", type.name()));
+        };
+    }
+
     default CurrentLimits getNullableCurrentLimits(TwoSides side) {
         return switch (side) {
             case ONE -> getNullableCurrentLimits1();