Refactor commit b32f39d

Author: Tristan-WorkGH

src/main/java/org/gridsuite/network/map/dto/common/CurrentLimitsData.java

@@ -8,8 +8,9 @@
 
 import com.fasterxml.jackson.annotation.JsonInclude;
 import lombok.Builder;
-import lombok.EqualsAndHashCode;
-import lombok.Getter;
+import lombok.Data;
+import lombok.With;
+import lombok.experimental.Accessors;
 import org.springframework.util.CollectionUtils;
 
 import java.util.List;
@@ -19,9 +20,10 @@
  * @author David Braquart <david.braquart at rte-france.com>
  *     == a powsybl OperationalLimitsGroup == a LimitSet
  */
+@With
 @Builder
-@Getter
-@EqualsAndHashCode
+@Data
+@Accessors(chain = true)
 public class CurrentLimitsData {
     // may be null in case we just need the selected limit set and don't really need its name/id
     @JsonInclude(JsonInclude.Include.NON_NULL)

src/main/java/org/gridsuite/network/map/dto/mapper/LineInfosMapper.java

@@ -65,11 +65,10 @@ private static LineFormInfos toFormInfos(Identifiable<?> identifiable) {
                 .b1(line.getB1())
                 .g2(line.getG2())
                 .b2(line.getB2())
-                .properties(getProperties(line))
                 .selectedOperationalLimitsGroup1(line.getSelectedOperationalLimitsGroupId1().orElse(null))
-                .selectedOperationalLimitsGroup2(line.getSelectedOperationalLimitsGroupId2().orElse(null));
-
-        mergeCurrentLimits(line.getOperationalLimitsGroups1(), line.getOperationalLimitsGroups2(), builder::currentLimits);
+                .selectedOperationalLimitsGroup2(line.getSelectedOperationalLimitsGroupId2().orElse(null))
+                .currentLimits(mergeCurrentLimits(line.getOperationalLimitsGroups1(), line.getOperationalLimitsGroups2()))
+                .properties(getProperties(line));
 
         buildCurrentLimits(line.getOperationalLimitsGroups1(), builder::currentLimits1);
         buildCurrentLimits(line.getOperationalLimitsGroups2(), builder::currentLimits2);

src/main/java/org/gridsuite/network/map/dto/mapper/TwoWindingsTransformerInfosMapper.java

@@ -66,6 +66,9 @@ private static TwoWindingsTransformerFormInfos toFormInfos(Identifiable<?> ident
                 .g(twoWT.getG())
                 .ratedU1(twoWT.getRatedU1())
                 .ratedU2(twoWT.getRatedU2())
+                .selectedOperationalLimitsGroup1(twoWT.getSelectedOperationalLimitsGroupId1().orElse(null))
+                .selectedOperationalLimitsGroup2(twoWT.getSelectedOperationalLimitsGroupId2().orElse(null))
+                .currentLimits(mergeCurrentLimits(twoWT.getOperationalLimitsGroups1(), twoWT.getOperationalLimitsGroups2()))
                 .properties(getProperties(twoWT));
 
         builder.busOrBusbarSectionId1(getBusOrBusbarSection(terminal1))
@@ -77,10 +80,7 @@ private static TwoWindingsTransformerFormInfos toFormInfos(Identifiable<?> ident
         builder.q2(nullIfNan(terminal2.getQ()));
         builder.i1(nullIfNan(terminal1.getI()));
         builder.i2(nullIfNan(terminal2.getI()));
-        builder.selectedOperationalLimitsGroup1(twoWT.getSelectedOperationalLimitsGroupId1().orElse(null));
-        builder.selectedOperationalLimitsGroup2(twoWT.getSelectedOperationalLimitsGroupId2().orElse(null));
 
-        mergeCurrentLimits(twoWT.getOperationalLimitsGroups1(), twoWT.getOperationalLimitsGroups2(), builder::currentLimits);
 
         buildCurrentLimits(twoWT.getOperationalLimitsGroups1(), builder::currentLimits1);
         buildCurrentLimits(twoWT.getOperationalLimitsGroups2(), builder::currentLimits2);

src/main/java/org/gridsuite/network/map/dto/utils/ElementUtils.java

@@ -10,12 +10,13 @@
 import com.powsybl.iidm.network.*;
 import com.powsybl.iidm.network.extensions.*;
 import com.powsybl.math.graph.TraversalType;
+import lombok.NonNull;
 import org.gridsuite.network.map.dto.common.*;
 import org.gridsuite.network.map.dto.definition.extension.*;
 import org.gridsuite.network.map.dto.definition.threewindingstransformer.ThreeWindingsTransformerTabInfos;
+import org.springframework.lang.Nullable;
 import org.springframework.util.CollectionUtils;
 
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
@@ -24,6 +25,7 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static org.gridsuite.network.map.dto.common.CurrentLimitsData.Applicability.*;
 
@@ -93,85 +95,55 @@ public static void buildCurrentLimits(Collection<OperationalLimitsGroup> current
         }
     }
 
-    private static CurrentLimitsData copyCurrentLimitsData(CurrentLimitsData currentLimitsData, CurrentLimitsData.Applicability applicability) {
-        return CurrentLimitsData.builder()
-            .id(currentLimitsData.getId())
-            .applicability(applicability)
-            .temporaryLimits(currentLimitsData.getTemporaryLimits())
-            .permanentLimit(currentLimitsData.getPermanentLimit()).build();
-    }
-
     /**
+     * Combine 2 sides in one list.
      * @return id of the selected operation limits group 1 and 2 if they have been renamed
      */
-    public static void mergeCurrentLimits(Collection<OperationalLimitsGroup> operationalLimitsGroups1,
-                                                          Collection<OperationalLimitsGroup> operationalLimitsGroups2,
-                                                          Consumer<List<CurrentLimitsData>> build) {
-        List<CurrentLimitsData> mergedLimitsData = new ArrayList<>();
-
+    @Nullable
+    public static List<CurrentLimitsData> mergeCurrentLimits(@NonNull final Collection<OperationalLimitsGroup> operationalLimitsGroups1,
+                                                             @NonNull final Collection<OperationalLimitsGroup> operationalLimitsGroups2) {
         // Build temporary limit from side 1 and 2
-        List<CurrentLimitsData> currentLimitsData1 = operationalLimitsGroups1.stream()
-            .map(ElementUtils::operationalLimitsGroupToMapDataCurrentLimits).toList();
-        ArrayList<CurrentLimitsData> currentLimitsData2 = new ArrayList<>(operationalLimitsGroups2.stream()
-            .map(ElementUtils::operationalLimitsGroupToMapDataCurrentLimits).toList());
-
-        // combine 2 sides in one list
+        final List<CurrentLimitsData> currentLimitsData1 = operationalLimitsGroups1.stream()
+            .map(operationalLimitsGroup -> operationalLimitsGroupToMapDataCurrentLimits(operationalLimitsGroup).setApplicability(SIDE1))
+            .toList();
+        final List<CurrentLimitsData> currentLimitsData2 = operationalLimitsGroups2.stream()
+            .map(operationalLimitsGroup -> operationalLimitsGroupToMapDataCurrentLimits(operationalLimitsGroup).setApplicability(SIDE2))
+            .toList();
 
         // simple case : one of the arrays are empty
         if (currentLimitsData2.isEmpty() && !currentLimitsData1.isEmpty()) {
-            for (CurrentLimitsData currentLimitsData : currentLimitsData1) {
-                mergedLimitsData.add(copyCurrentLimitsData(currentLimitsData, SIDE1));
-            }
-            build.accept(mergedLimitsData);
-            return;
+            return currentLimitsData1;
         }
         if (currentLimitsData1.isEmpty() && !currentLimitsData2.isEmpty()) {
-            for (CurrentLimitsData currentLimitsData : currentLimitsData2) {
-                mergedLimitsData.add(copyCurrentLimitsData(currentLimitsData, SIDE2));
-            }
-            build.accept(mergedLimitsData);
-            return;
+            return currentLimitsData2;
         }
 
         // more complex case
-        for (CurrentLimitsData limitsData : currentLimitsData1) {
-            Optional<CurrentLimitsData> l2 = currentLimitsData2.stream().filter(l -> l.getId().equals(limitsData.getId())).findFirst();
-
-            if (l2.isPresent()) {
-                CurrentLimitsData limitsData2 = l2.get();
-                // Only side one has limits
-                if (limitsData.hasLimits() && !limitsData2.hasLimits()) {
-                    mergedLimitsData.add(copyCurrentLimitsData(limitsData, SIDE1));
-                    // only side two has limits
-                } else if (limitsData2.hasLimits() && !limitsData.hasLimits()) {
-                    mergedLimitsData.add(copyCurrentLimitsData(limitsData2, SIDE2));
-                } else {
-                    // both sides have limits and limits are equals
-                    if (limitsData.limitsEquals(limitsData2)) {
-                        mergedLimitsData.add(copyCurrentLimitsData(limitsData, EQUIPMENT));
-                        // both side have limits and they are different : create 2 different limit sets
-                    } else {
-                        // Side 1
-                        mergedLimitsData.add(copyCurrentLimitsData(limitsData, SIDE1));
-                        // Side 2
-                        mergedLimitsData.add(copyCurrentLimitsData(limitsData2, SIDE2));
+        return Stream.concat(currentLimitsData1.stream(), currentLimitsData2.stream())
+            .collect(Collectors.groupingByConcurrent(CurrentLimitsData::getId))
+            .values()
+            .parallelStream()
+            .<CurrentLimitsData>mapMulti((currentLimitsData, acc) -> {
+                if (currentLimitsData.isEmpty() || currentLimitsData.size() > 2) {
+                    throw new UnsupportedOperationException("IDs are assumed unique in each lists");
+                } else if (currentLimitsData.size() == 2) {
+                    final CurrentLimitsData limitsData = currentLimitsData.get(0);
+                    final CurrentLimitsData limitsData2 = currentLimitsData.get(1);
+                    if (limitsData.hasLimits() && !limitsData2.hasLimits()) { // Only side one has limits
+                        acc.accept(limitsData);
+                        return;
+                    } else if (limitsData2.hasLimits() && !limitsData.hasLimits()) { // only side two has limits
+                        acc.accept(limitsData2);
+                        return;
+                    } else if (limitsData.limitsEquals(limitsData2)) { // both sides have limits and limits are equals
+                        acc.accept(limitsData.setApplicability(EQUIPMENT));
+                        return;
                     }
+                    // both side have limits and are different: create 2 different limit sets
                 }
-                // remove processed limits from side 2
-                currentLimitsData2.remove(l2.get());
-            } else {
-                mergedLimitsData.add(copyCurrentLimitsData(limitsData, SIDE1));
-            }
-        }
-
-        // add remaining limits from side 2
-        for (CurrentLimitsData limitsData : currentLimitsData2) {
-            mergedLimitsData.add(copyCurrentLimitsData(limitsData, SIDE2));
-        }
-
-        if (!mergedLimitsData.isEmpty()) {
-            build.accept(mergedLimitsData);
-        }
+                currentLimitsData.forEach(acc);
+            })
+            .toList();
     }
 
     public static Optional<StandbyAutomatonInfos> toStandbyAutomaton(StaticVarCompensator staticVarCompensator) {