Don't throw exception if boolean is false

Signed-off-by: Coline PILOQUET <coline.piloquet@rte-france.com>

java/src/main/java/com/powsybl/dataframe/network/adders/AbstractBranchSeries.java

@@ -58,6 +58,6 @@ protected void setBranchAttributes(BranchAdder<?, ?> adder, int row) {
         applyIfPresent(nodes2, row, adder::setNode2);
     }
 
-    abstract BranchAdder create(Network network, int row);
+    abstract BranchAdder create(Network network, int row, boolean throwException);
 
 }

java/src/main/java/com/powsybl/dataframe/network/adders/AbstractFeederBaysSeries.java

@@ -19,10 +19,10 @@ public abstract class AbstractFeederBaysSeries {
 
     abstract AbstractBranchSeries createTypedSeries(UpdatingDataframe dataframe);
 
-    public CreateBranchFeederBaysBuilder createBuilder(Network n, UpdatingDataframe dataframe, int row) {
+    public CreateBranchFeederBaysBuilder createBuilder(Network n, UpdatingDataframe dataframe, int row, boolean throwException) {
         AbstractBranchSeries series = createTypedSeries(dataframe);
         CreateBranchFeederBaysBuilder builder = new CreateBranchFeederBaysBuilder();
-        BranchAdder<?, ?> lAdder = series.create(n, row);
+        BranchAdder<?, ?> lAdder = series.create(n, row, throwException);
         builder.withBranchAdder(lAdder);
         applyIfPresent(dataframe.getStrings("bus_or_busbar_section_id_1"), row, builder::withBusOrBusbarSectionId1);
         applyIfPresent(dataframe.getStrings("bus_or_busbar_section_id_2"), row, builder::withBusOrBusbarSectionId2);

java/src/main/java/com/powsybl/dataframe/network/adders/AbstractSimpleAdder.java

@@ -38,30 +38,30 @@ public void addElementsWithBay(Network network, UpdatingDataframe dataframe, boo
     }
 
     public void addElements(Network network, UpdatingDataframe dataframe) {
-        addElements(network, dataframe, (n, df, adder, row, throwException, reporter) -> add(adder), false, Reporter.NO_OP);
+        addElements(network, dataframe, (n, df, adder, row, throwException, reporter) -> add(adder), true, Reporter.NO_OP);
     }
 
     void addElements(Network network, UpdatingDataframe dataframe, AbstractSimpleAdder.AdditionStrategy addition, boolean throwException, Reporter reporter) {
         //do nothing
     }
 
     private void add(InjectionAdder<?, ?> injectionAdder) {
-        if (injectionAdder instanceof LoadAdder) {
-            ((LoadAdder) injectionAdder).add();
-        } else if (injectionAdder instanceof BatteryAdder) {
-            ((BatteryAdder) injectionAdder).add();
-        } else if (injectionAdder instanceof DanglingLineAdder) {
-            ((DanglingLineAdder) injectionAdder).add();
-        } else if (injectionAdder instanceof GeneratorAdder) {
-            ((GeneratorAdder) injectionAdder).add();
-        } else if (injectionAdder instanceof ShuntCompensatorAdder) {
-            ((ShuntCompensatorAdder) injectionAdder).add();
-        } else if (injectionAdder instanceof StaticVarCompensatorAdder) {
-            ((StaticVarCompensatorAdder) injectionAdder).add();
-        } else if (injectionAdder instanceof LccConverterStationAdder) {
-            ((LccConverterStationAdder) injectionAdder).add();
-        } else if (injectionAdder instanceof VscConverterStationAdder) {
-            ((VscConverterStationAdder) injectionAdder).add();
+        if (injectionAdder instanceof LoadAdder loadAdder) {
+            loadAdder.add();
+        } else if (injectionAdder instanceof BatteryAdder batteryAdder) {
+            batteryAdder.add();
+        } else if (injectionAdder instanceof DanglingLineAdder danglingLineAdder) {
+            danglingLineAdder.add();
+        } else if (injectionAdder instanceof GeneratorAdder generatorAdder) {
+            generatorAdder.add();
+        } else if (injectionAdder instanceof ShuntCompensatorAdder shuntCompensatorAdder) {
+            shuntCompensatorAdder.add();
+        } else if (injectionAdder instanceof StaticVarCompensatorAdder staticVarCompensatorAdder) {
+            staticVarCompensatorAdder.add();
+        } else if (injectionAdder instanceof LccConverterStationAdder lccConverterStationAdder) {
+            lccConverterStationAdder.add();
+        } else if (injectionAdder instanceof VscConverterStationAdder vscConverterStationAdder) {
+            vscConverterStationAdder.add();
         } else {
             throw new AssertionError("Given InjectionAdder not supported: " + injectionAdder.getClass().getName());
         }

java/src/main/java/com/powsybl/dataframe/network/adders/BatteryDataframeAdder.java

@@ -13,6 +13,7 @@
 import com.powsybl.dataframe.update.UpdatingDataframe;
 import com.powsybl.iidm.network.BatteryAdder;
 import com.powsybl.iidm.network.Network;
+import com.powsybl.iidm.network.VoltageLevel;
 
 import java.util.Collections;
 import java.util.List;
@@ -65,24 +66,30 @@ private static class BatterySeries extends InjectionSeries {
             this.busOrBusbarSections = dataframe.getStrings("bus_or_busbar_section_id");
         }
 
-        BatteryAdder createAdder(Network network, int row) {
-            BatteryAdder batteryAdder = getVoltageLevelOrThrowWithBusOrBusbarSectionId(network, row, voltageLevels, busOrBusbarSections)
-                    .newBattery();
-            setInjectionAttributes(batteryAdder, row);
-            applyIfPresent(maxP, row, batteryAdder::setMaxP);
-            applyIfPresent(minP, row, batteryAdder::setMinP);
-            applyIfPresent(targetP, row, batteryAdder::setTargetP);
-            applyIfPresent(targetQ, row, batteryAdder::setTargetQ);
-            return batteryAdder;
+        BatteryAdder createAdder(Network network, int row, boolean throwException) {
+            VoltageLevel vl = getVoltageLevelOrThrowWithBusOrBusbarSectionId(network, row, voltageLevels, busOrBusbarSections, throwException);
+            if (vl != null) {
+                BatteryAdder batteryAdder = vl.newBattery();
+                setInjectionAttributes(batteryAdder, row);
+                applyIfPresent(maxP, row, batteryAdder::setMaxP);
+                applyIfPresent(minP, row, batteryAdder::setMinP);
+                applyIfPresent(targetP, row, batteryAdder::setTargetP);
+                applyIfPresent(targetQ, row, batteryAdder::setTargetQ);
+                return batteryAdder;
+            } else {
+                return null;
+            }
         }
     }
 
     @Override
     public void addElements(Network network, UpdatingDataframe dataframe, AdditionStrategy addition, boolean throwException, Reporter reporter) {
         BatterySeries series = new BatterySeries(dataframe);
         for (int row = 0; row < dataframe.getRowCount(); row++) {
-            BatteryAdder adder = series.createAdder(network, row);
-            addition.add(network, dataframe, adder, row, throwException, reporter);
+            BatteryAdder adder = series.createAdder(network, row, throwException);
+            if (adder != null) {
+                addition.add(network, dataframe, adder, row, throwException, reporter);
+            }
         }
     }
 }

java/src/main/java/com/powsybl/dataframe/network/adders/DanglingLineDataframeAdder.java

@@ -13,6 +13,7 @@
 import com.powsybl.dataframe.update.UpdatingDataframe;
 import com.powsybl.iidm.network.DanglingLineAdder;
 import com.powsybl.iidm.network.Network;
+import com.powsybl.iidm.network.VoltageLevel;
 
 import java.util.Collections;
 import java.util.List;
@@ -73,27 +74,33 @@ private static class DanglingLineSeries extends InjectionSeries {
             this.ucteXnodeCode = dataframe.getStrings("ucte_xnode_code");
         }
 
-        DanglingLineAdder createAdder(Network network, int row) {
-            DanglingLineAdder adder = getVoltageLevelOrThrowWithBusOrBusbarSectionId(network, row, voltageLevels, busOrBusbarSections)
-                    .newDanglingLine();
-            setInjectionAttributes(adder, row);
-            applyIfPresent(p0, row, adder::setP0);
-            applyIfPresent(q0, row, adder::setQ0);
-            applyIfPresent(r, row, adder::setR);
-            applyIfPresent(x, row, adder::setX);
-            applyIfPresent(g, row, adder::setG);
-            applyIfPresent(b, row, adder::setB);
-            applyIfPresent(ucteXnodeCode, row, adder::setPairingKey);
-            return adder;
+        DanglingLineAdder createAdder(Network network, int row, boolean throwException) {
+            VoltageLevel vl = getVoltageLevelOrThrowWithBusOrBusbarSectionId(network, row, voltageLevels, busOrBusbarSections, throwException);
+            if (vl != null) {
+                DanglingLineAdder adder = vl.newDanglingLine();
+                setInjectionAttributes(adder, row);
+                applyIfPresent(p0, row, adder::setP0);
+                applyIfPresent(q0, row, adder::setQ0);
+                applyIfPresent(r, row, adder::setR);
+                applyIfPresent(x, row, adder::setX);
+                applyIfPresent(g, row, adder::setG);
+                applyIfPresent(b, row, adder::setB);
+                applyIfPresent(ucteXnodeCode, row, adder::setPairingKey);
+                return adder;
+            } else {
+                return null;
+            }
         }
     }
 
     @Override
     public void addElements(Network network, UpdatingDataframe dataframe, AdditionStrategy additionStrategy, boolean throwException, Reporter reporter) {
         DanglingLineSeries series = new DanglingLineSeries(dataframe);
         for (int row = 0; row < dataframe.getRowCount(); row++) {
-            DanglingLineAdder adder = series.createAdder(network, row);
-            additionStrategy.add(network, dataframe, adder, row, throwException, reporter);
+            DanglingLineAdder adder = series.createAdder(network, row, throwException);
+            if (adder != null) {
+                additionStrategy.add(network, dataframe, adder, row, throwException, reporter);
+            }
         }
     }
 }

java/src/main/java/com/powsybl/dataframe/network/adders/GeneratorDataframeAdder.java

@@ -80,31 +80,36 @@ private static class GeneratorSeries extends InjectionSeries {
             this.regulatingElements = dataframe.getStrings("regulating_element_id");
         }
 
-        GeneratorAdder createAdder(Network network, int row) {
-            GeneratorAdder adder = getVoltageLevelOrThrowWithBusOrBusbarSectionId(network, row, voltageLevels, busOrBusbarSections)
-                    .newGenerator();
-
-            setInjectionAttributes(adder, row);
-            applyIfPresent(maxP, row, adder::setMaxP);
-            applyIfPresent(minP, row, adder::setMinP);
-            applyIfPresent(targetP, row, adder::setTargetP);
-            applyIfPresent(targetQ, row, adder::setTargetQ);
-            applyIfPresent(targetV, row, adder::setTargetV);
-            applyIfPresent(ratedS, row, adder::setRatedS);
-            applyBooleanIfPresent(voltageRegulatorOn, row, adder::setVoltageRegulatorOn);
-            applyIfPresent(energySource, row, EnergySource.class, adder::setEnergySource);
-            applyIfPresent(regulatingElements, row, elementId -> NetworkUtil
-                    .setRegulatingTerminal(adder::setRegulatingTerminal, network, elementId));
-            return adder;
+        GeneratorAdder createAdder(Network network, int row, boolean throwException) {
+            VoltageLevel vl = getVoltageLevelOrThrowWithBusOrBusbarSectionId(network, row, voltageLevels, busOrBusbarSections, throwException);
+            if (vl != null) {
+                GeneratorAdder adder = vl.newGenerator();
+                setInjectionAttributes(adder, row);
+                applyIfPresent(maxP, row, adder::setMaxP);
+                applyIfPresent(minP, row, adder::setMinP);
+                applyIfPresent(targetP, row, adder::setTargetP);
+                applyIfPresent(targetQ, row, adder::setTargetQ);
+                applyIfPresent(targetV, row, adder::setTargetV);
+                applyIfPresent(ratedS, row, adder::setRatedS);
+                applyBooleanIfPresent(voltageRegulatorOn, row, adder::setVoltageRegulatorOn);
+                applyIfPresent(energySource, row, EnergySource.class, adder::setEnergySource);
+                applyIfPresent(regulatingElements, row, elementId -> NetworkUtil
+                        .setRegulatingTerminal(adder::setRegulatingTerminal, network, elementId));
+                return adder;
+            } else {
+                return null;
+            }
         }
     }
 
     @Override
     public void addElements(Network network, UpdatingDataframe dataframe, AdditionStrategy addition, boolean throwException, Reporter reporter) {
         GeneratorSeries series = new GeneratorSeries(dataframe);
         for (int row = 0; row < dataframe.getRowCount(); row++) {
-            GeneratorAdder adder = series.createAdder(network, row);
-            addition.add(network, dataframe, adder, row, throwException, reporter);
+            GeneratorAdder adder = series.createAdder(network, row, throwException);
+            if (adder != null) {
+                addition.add(network, dataframe, adder, row, throwException, reporter);
+            }
         }
     }
 

java/src/main/java/com/powsybl/dataframe/network/adders/LccStationDataframeAdder.java

@@ -13,6 +13,7 @@
 import com.powsybl.dataframe.update.UpdatingDataframe;
 import com.powsybl.iidm.network.LccConverterStationAdder;
 import com.powsybl.iidm.network.Network;
+import com.powsybl.iidm.network.VoltageLevel;
 
 import java.util.Collections;
 import java.util.List;
@@ -58,22 +59,28 @@ private static class LccStationSeries extends InjectionSeries {
             this.busOrBusbarSections = dataframe.getStrings("bus_or_busbar_section_id");
         }
 
-        LccConverterStationAdder createAdder(Network network, int row) {
-            LccConverterStationAdder adder = getVoltageLevelOrThrowWithBusOrBusbarSectionId(network, row, voltageLevels, busOrBusbarSections)
-                    .newLccConverterStation();
-            setInjectionAttributes(adder, row);
-            applyIfPresent(lossFactors, row, f -> adder.setLossFactor((float) f));
-            applyIfPresent(powerFactors, row, f -> adder.setPowerFactor((float) f));
-            return adder;
+        LccConverterStationAdder createAdder(Network network, int row, boolean throwException) {
+            VoltageLevel vl = getVoltageLevelOrThrowWithBusOrBusbarSectionId(network, row, voltageLevels, busOrBusbarSections, throwException);
+            if (vl != null) {
+                LccConverterStationAdder adder = vl.newLccConverterStation();
+                setInjectionAttributes(adder, row);
+                applyIfPresent(lossFactors, row, f -> adder.setLossFactor((float) f));
+                applyIfPresent(powerFactors, row, f -> adder.setPowerFactor((float) f));
+                return adder;
+            } else {
+                return null;
+            }
         }
     }
 
     @Override
     public void addElements(Network network, UpdatingDataframe dataframe, AdditionStrategy additionStrategy, boolean throwException, Reporter reporter) {
         LccStationSeries series = new LccStationSeries(dataframe);
         for (int row = 0; row < dataframe.getRowCount(); row++) {
-            LccConverterStationAdder adder = series.createAdder(network, row);
-            additionStrategy.add(network, dataframe, adder, row, throwException, reporter);
+            LccConverterStationAdder adder = series.createAdder(network, row, throwException);
+            if (adder != null) {
+                additionStrategy.add(network, dataframe, adder, row, throwException, reporter);
+            }
         }
     }
 }

java/src/main/java/com/powsybl/dataframe/network/adders/LineDataframeAdder.java

@@ -48,7 +48,7 @@ public List<List<SeriesMetadata>> getMetadata() {
     public void addElements(Network network, UpdatingDataframe dataframe) {
         LineSeries series = new LineSeries(dataframe);
         for (int row = 0; row < dataframe.getRowCount(); row++) {
-            series.create(network, row).add();
+            series.create(network, row, true).add();
         }
     }
 }

java/src/main/java/com/powsybl/dataframe/network/adders/LineSeries.java

@@ -26,7 +26,7 @@ public class LineSeries extends AbstractBranchSeries {
         this.x = dataframe.getDoubles("x");
     }
 
-    LineAdder create(Network network, int row) {
+    LineAdder create(Network network, int row, boolean throwException) {
         LineAdder adder = network.newLine();
         setBranchAttributes(adder, row);
         applyIfPresent(b1, row, adder::setB1);

java/src/main/java/com/powsybl/dataframe/network/adders/LoadDataframeAdder.java

@@ -14,6 +14,7 @@
 import com.powsybl.iidm.network.LoadAdder;
 import com.powsybl.iidm.network.LoadType;
 import com.powsybl.iidm.network.Network;
+import com.powsybl.iidm.network.VoltageLevel;
 
 import java.util.Collections;
 import java.util.List;
@@ -62,23 +63,28 @@ private static class LoadSeries extends InjectionSeries {
             this.busOrBusbarSections = dataframe.getStrings("bus_or_busbar_section_id");
         }
 
-        LoadAdder createAdder(Network network, int row) {
-            LoadAdder adder = getVoltageLevelOrThrowWithBusOrBusbarSectionId(network, row, voltageLevels, busOrBusbarSections)
-                    .newLoad();
-            setInjectionAttributes(adder, row);
-            applyIfPresent(p0, row, adder::setP0);
-            applyIfPresent(q0, row, adder::setQ0);
-            applyIfPresent(type, row, LoadType.class, adder::setLoadType);
-            return adder;
+        LoadAdder createAdder(Network network, int row, boolean throwException) {
+            VoltageLevel vl = getVoltageLevelOrThrowWithBusOrBusbarSectionId(network, row, voltageLevels, busOrBusbarSections, throwException);
+            if (vl != null) {
+                LoadAdder adder = vl.newLoad();
+                setInjectionAttributes(adder, row);
+                applyIfPresent(p0, row, adder::setP0);
+                applyIfPresent(q0, row, adder::setQ0);
+                applyIfPresent(type, row, LoadType.class, adder::setLoadType);
+                return adder;
+            }
+            return null;
         }
     }
 
     @Override
     public void addElements(Network network, UpdatingDataframe dataframe, AdditionStrategy addition, boolean throwException, Reporter reporter) {
         LoadSeries series = new LoadSeries(dataframe);
         for (int row = 0; row < dataframe.getRowCount(); row++) {
-            LoadAdder adder = series.createAdder(network, row);
-            addition.add(network, dataframe, adder, row, throwException, reporter);
+            LoadAdder adder = series.createAdder(network, row, throwException);
+            if (adder != null) {
+                addition.add(network, dataframe, adder, row, throwException, reporter);
+            }
         }
     }
 }