diff --git a/network-store-client/src/main/java/com/powsybl/network/store/client/BufferedNetworkStoreClient.java b/network-store-client/src/main/java/com/powsybl/network/store/client/BufferedNetworkStoreClient.java index 1863d78c3..d820def09 100644 --- a/network-store-client/src/main/java/com/powsybl/network/store/client/BufferedNetworkStoreClient.java +++ b/network-store-client/src/main/java/com/powsybl/network/store/client/BufferedNetworkStoreClient.java @@ -33,7 +33,7 @@ * @author Franck Lecuyer * @author Etienne Homer */ -public class BufferedNetworkStoreClient extends AbstractForwardingNetworkStoreClient { +public class BufferedNetworkStoreClient extends AbstractForwardingNetworkStoreClient { private static final Logger LOGGER = LoggerFactory.getLogger(BufferedNetworkStoreClient.class); diff --git a/network-store-client/src/main/java/com/powsybl/network/store/client/PreloadingNetworkStoreClient.java b/network-store-client/src/main/java/com/powsybl/network/store/client/PreloadingNetworkStoreClient.java index 3e064a117..b437e2925 100644 --- a/network-store-client/src/main/java/com/powsybl/network/store/client/PreloadingNetworkStoreClient.java +++ b/network-store-client/src/main/java/com/powsybl/network/store/client/PreloadingNetworkStoreClient.java @@ -10,7 +10,6 @@ import com.powsybl.network.store.client.util.ExecutorUtil; import com.powsybl.network.store.iidm.impl.AbstractForwardingNetworkStoreClient; import com.powsybl.network.store.iidm.impl.CachedNetworkStoreClient; -import com.powsybl.network.store.iidm.impl.NetworkCollectionIndex; import com.powsybl.network.store.iidm.impl.NetworkStoreClient; import com.powsybl.network.store.model.*; import org.slf4j.Logger; @@ -26,7 +25,7 @@ * @author Geoffroy Jamgotchian * @author Etienne Homer */ -public class PreloadingNetworkStoreClient extends AbstractForwardingNetworkStoreClient implements NetworkStoreClient { +public class PreloadingNetworkStoreClient extends AbstractForwardingNetworkStoreClient implements NetworkStoreClient { private static final Logger LOGGER = LoggerFactory.getLogger(PreloadingNetworkStoreClient.class); @@ -53,9 +52,8 @@ public class PreloadingNetworkStoreClient extends AbstractForwardingNetworkStore private final boolean allCollectionsNeededForBusView; private final ExecutorService executorService; - - private final NetworkCollectionIndex> cachedResourceTypes - = new NetworkCollectionIndex<>(() -> EnumSet.noneOf(ResourceType.class)); + //TODO: Need to be by networkuuid/variantNum + not sure it's a good idea to use both ensureCached and ensureAllCollectionForBusViewCached + private boolean allCollectionsNeededForBusViewLoaded = false; public PreloadingNetworkStoreClient(CachedNetworkStoreClient delegate, boolean allCollectionsNeededForBusView, ExecutorService executorService) { @@ -91,7 +89,7 @@ private void loadToCache(ResourceType resourceType, UUID networkUuid, int varian } } - private void loadAllCollectionsNeededForBusView(UUID networkUuid, int variantNum, Set resourceTypes) { + private void loadAllCollectionsNeededForBusView(UUID networkUuid, int variantNum) { // directly load all collections Stopwatch stopwatch = Stopwatch.createStarted(); List> futures = new ArrayList<>(RESOURCE_TYPES_NEEDED_FOR_BUS_VIEW.size()); @@ -99,73 +97,77 @@ private void loadAllCollectionsNeededForBusView(UUID networkUuid, int variantNum futures.add(executorService.submit(() -> loadToCache(resourceType, networkUuid, variantNum))); } ExecutorUtil.waitAllFutures(futures); - resourceTypes.addAll(RESOURCE_TYPES_NEEDED_FOR_BUS_VIEW); + allCollectionsNeededForBusViewLoaded = true; stopwatch.stop(); LOGGER.info("All collections needed for bus view loaded in {} ms", stopwatch.elapsed(TimeUnit.MILLISECONDS)); } - boolean isResourceTypeCached(UUID networkUuid, int variantNum, ResourceType resourceType) { - Set resourceTypes = cachedResourceTypes.getCollection(networkUuid, variantNum); + private void ensureCollectionCached(ResourceType resourceType, UUID networkUuid, int variantNum) { Objects.requireNonNull(resourceType); - return resourceTypes.contains(resourceType); + Objects.requireNonNull(networkUuid); + if (shouldLoadAllCollectionsNeededForBusView(resourceType)) { + loadAllCollectionsNeededForBusView(networkUuid, variantNum); + } else { + loadToCache(resourceType, networkUuid, variantNum); + } } - private void ensureCached(ResourceType resourceType, UUID networkUuid, int variantNum) { + private void ensureAllCollectionForBusViewCached(ResourceType resourceType, UUID networkUuid, int variantNum) { Objects.requireNonNull(resourceType); Objects.requireNonNull(networkUuid); - Set resourceTypes = cachedResourceTypes.getCollection(networkUuid, variantNum); - if (!resourceTypes.contains(resourceType)) { - if (allCollectionsNeededForBusView && RESOURCE_TYPES_NEEDED_FOR_BUS_VIEW.contains(resourceType)) { - loadAllCollectionsNeededForBusView(networkUuid, variantNum, resourceTypes); - } else { - loadToCache(resourceType, networkUuid, variantNum); - resourceTypes.add(resourceType); - } + if (shouldLoadAllCollectionsNeededForBusView(resourceType)) { + loadAllCollectionsNeededForBusView(networkUuid, variantNum); } } + boolean shouldLoadAllCollectionsNeededForBusView(ResourceType resourceType) { + return !allCollectionsNeededForBusViewLoaded + && allCollectionsNeededForBusView + && RESOURCE_TYPES_NEEDED_FOR_BUS_VIEW.contains(resourceType); + } + @Override public void deleteNetwork(UUID networkUuid) { delegate.deleteNetwork(networkUuid); - cachedResourceTypes.removeCollection(networkUuid); + allCollectionsNeededForBusViewLoaded = false; } @Override public void deleteNetwork(UUID networkUuid, int variantNum) { delegate.deleteNetwork(networkUuid, variantNum); - cachedResourceTypes.removeCollection(networkUuid, variantNum); + allCollectionsNeededForBusViewLoaded = false; } @Override public void createSubstations(UUID networkUuid, List> substationResources) { for (Resource substationResource : substationResources) { - ensureCached(ResourceType.SUBSTATION, networkUuid, substationResource.getVariantNum()); + ensureCollectionCached(ResourceType.SUBSTATION, networkUuid, substationResource.getVariantNum()); } delegate.createSubstations(networkUuid, substationResources); } @Override public List> getSubstations(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.SUBSTATION, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.SUBSTATION, networkUuid, variantNum); return delegate.getSubstations(networkUuid, variantNum); } @Override public Optional> getSubstation(UUID networkUuid, int variantNum, String substationId) { - ensureCached(ResourceType.SUBSTATION, networkUuid, variantNum); + ensureCollectionCached(ResourceType.SUBSTATION, networkUuid, variantNum); return delegate.getSubstation(networkUuid, variantNum, substationId); } @Override public void removeSubstations(UUID networkUuid, int variantNum, List substationsId) { - ensureCached(ResourceType.SUBSTATION, networkUuid, variantNum); + ensureCollectionCached(ResourceType.SUBSTATION, networkUuid, variantNum); delegate.removeSubstations(networkUuid, variantNum, substationsId); } @Override public void updateSubstations(UUID networkUuid, List> substationResources, AttributeFilter attributeFilter) { for (Resource substationResource : substationResources) { - ensureCached(ResourceType.SUBSTATION, networkUuid, substationResource.getVariantNum()); + ensureCollectionCached(ResourceType.SUBSTATION, networkUuid, substationResource.getVariantNum()); } delegate.updateSubstations(networkUuid, substationResources, attributeFilter); } @@ -173,249 +175,249 @@ public void updateSubstations(UUID networkUuid, List> voltageLevelResources) { for (Resource voltageLevelResource : voltageLevelResources) { - ensureCached(ResourceType.VOLTAGE_LEVEL, networkUuid, voltageLevelResource.getVariantNum()); + ensureCollectionCached(ResourceType.VOLTAGE_LEVEL, networkUuid, voltageLevelResource.getVariantNum()); } delegate.createVoltageLevels(networkUuid, voltageLevelResources); } @Override public Optional> getVoltageLevel(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.VOLTAGE_LEVEL, networkUuid, variantNum); + ensureCollectionCached(ResourceType.VOLTAGE_LEVEL, networkUuid, variantNum); return delegate.getVoltageLevel(networkUuid, variantNum, voltageLevelId); } @Override public List> getVoltageLevels(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.VOLTAGE_LEVEL, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.VOLTAGE_LEVEL, networkUuid, variantNum); return delegate.getVoltageLevels(networkUuid, variantNum); } @Override public List> getVoltageLevelsInSubstation(UUID networkUuid, int variantNum, String substationId) { - ensureCached(ResourceType.VOLTAGE_LEVEL, networkUuid, variantNum); + ensureCollectionCached(ResourceType.VOLTAGE_LEVEL, networkUuid, variantNum); return delegate.getVoltageLevelsInSubstation(networkUuid, variantNum, substationId); } @Override public void removeVoltageLevels(UUID networkUuid, int variantNum, List voltageLevelsId) { - ensureCached(ResourceType.VOLTAGE_LEVEL, networkUuid, variantNum); + ensureCollectionCached(ResourceType.VOLTAGE_LEVEL, networkUuid, variantNum); delegate.removeVoltageLevels(networkUuid, variantNum, voltageLevelsId); } @Override public List> getVoltageLevelBusbarSections(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.BUSBAR_SECTION, networkUuid, variantNum); + ensureCollectionCached(ResourceType.BUSBAR_SECTION, networkUuid, variantNum); return delegate.getVoltageLevelBusbarSections(networkUuid, variantNum, voltageLevelId); } @Override public void removeBusBarSections(UUID networkUuid, int variantNum, List busBarSectionsId) { - ensureCached(ResourceType.BUSBAR_SECTION, networkUuid, variantNum); + ensureCollectionCached(ResourceType.BUSBAR_SECTION, networkUuid, variantNum); delegate.removeBusBarSections(networkUuid, variantNum, busBarSectionsId); } @Override public List> getVoltageLevelSwitches(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.SWITCH, networkUuid, variantNum); + ensureCollectionCached(ResourceType.SWITCH, networkUuid, variantNum); return delegate.getVoltageLevelSwitches(networkUuid, variantNum, voltageLevelId); } @Override public List> getVoltageLevelGenerators(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.GENERATOR, networkUuid, variantNum); + ensureCollectionCached(ResourceType.GENERATOR, networkUuid, variantNum); return delegate.getVoltageLevelGenerators(networkUuid, variantNum, voltageLevelId); } @Override public void removeGenerators(UUID networkUuid, int variantNum, List generatorsId) { - ensureCached(ResourceType.GENERATOR, networkUuid, variantNum); + ensureCollectionCached(ResourceType.GENERATOR, networkUuid, variantNum); delegate.removeGenerators(networkUuid, variantNum, generatorsId); } @Override public List> getVoltageLevelBatteries(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.BATTERY, networkUuid, variantNum); + ensureCollectionCached(ResourceType.BATTERY, networkUuid, variantNum); return delegate.getVoltageLevelBatteries(networkUuid, variantNum, voltageLevelId); } @Override public void removeBatteries(UUID networkUuid, int variantNum, List batteriesId) { - ensureCached(ResourceType.BATTERY, networkUuid, variantNum); + ensureCollectionCached(ResourceType.BATTERY, networkUuid, variantNum); delegate.removeBatteries(networkUuid, variantNum, batteriesId); } @Override public List> getVoltageLevelLoads(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.LOAD, networkUuid, variantNum); + ensureCollectionCached(ResourceType.LOAD, networkUuid, variantNum); return delegate.getVoltageLevelLoads(networkUuid, variantNum, voltageLevelId); } @Override public void removeLoads(UUID networkUuid, int variantNum, List loadsId) { - ensureCached(ResourceType.LOAD, networkUuid, variantNum); + ensureCollectionCached(ResourceType.LOAD, networkUuid, variantNum); delegate.removeLoads(networkUuid, variantNum, loadsId); } @Override public List> getVoltageLevelShuntCompensators(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.SHUNT_COMPENSATOR, networkUuid, variantNum); + ensureCollectionCached(ResourceType.SHUNT_COMPENSATOR, networkUuid, variantNum); return delegate.getVoltageLevelShuntCompensators(networkUuid, variantNum, voltageLevelId); } @Override public void removeShuntCompensators(UUID networkUuid, int variantNum, List shuntCompensatorsId) { - ensureCached(ResourceType.SHUNT_COMPENSATOR, networkUuid, variantNum); + ensureCollectionCached(ResourceType.SHUNT_COMPENSATOR, networkUuid, variantNum); delegate.removeShuntCompensators(networkUuid, variantNum, shuntCompensatorsId); } @Override public List> getVoltageLevelStaticVarCompensators(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.STATIC_VAR_COMPENSATOR, networkUuid, variantNum); + ensureCollectionCached(ResourceType.STATIC_VAR_COMPENSATOR, networkUuid, variantNum); return delegate.getVoltageLevelStaticVarCompensators(networkUuid, variantNum, voltageLevelId); } @Override public void removeStaticVarCompensators(UUID networkUuid, int variantNum, List staticVarCompensatorsId) { - ensureCached(ResourceType.STATIC_VAR_COMPENSATOR, networkUuid, variantNum); + ensureCollectionCached(ResourceType.STATIC_VAR_COMPENSATOR, networkUuid, variantNum); delegate.removeStaticVarCompensators(networkUuid, variantNum, staticVarCompensatorsId); } @Override public List> getVoltageLevelVscConverterStations(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.VSC_CONVERTER_STATION, networkUuid, variantNum); + ensureCollectionCached(ResourceType.VSC_CONVERTER_STATION, networkUuid, variantNum); return delegate.getVoltageLevelVscConverterStations(networkUuid, variantNum, voltageLevelId); } @Override public void removeVscConverterStations(UUID networkUuid, int variantNum, List vscConverterStationsId) { - ensureCached(ResourceType.VSC_CONVERTER_STATION, networkUuid, variantNum); + ensureCollectionCached(ResourceType.VSC_CONVERTER_STATION, networkUuid, variantNum); delegate.removeVscConverterStations(networkUuid, variantNum, vscConverterStationsId); } @Override public List> getVoltageLevelLccConverterStations(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.LCC_CONVERTER_STATION, networkUuid, variantNum); + ensureCollectionCached(ResourceType.LCC_CONVERTER_STATION, networkUuid, variantNum); return delegate.getVoltageLevelLccConverterStations(networkUuid, variantNum, voltageLevelId); } @Override public void removeLccConverterStations(UUID networkUuid, int variantNum, List lccConverterStationsId) { - ensureCached(ResourceType.LCC_CONVERTER_STATION, networkUuid, variantNum); + ensureCollectionCached(ResourceType.LCC_CONVERTER_STATION, networkUuid, variantNum); delegate.removeLccConverterStations(networkUuid, variantNum, lccConverterStationsId); } @Override public List> getVoltageLevelGrounds(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.GROUND, networkUuid, variantNum); + ensureCollectionCached(ResourceType.GROUND, networkUuid, variantNum); return delegate.getVoltageLevelGrounds(networkUuid, variantNum, voltageLevelId); } @Override public void removeGrounds(UUID networkUuid, int variantNum, List groundsId) { - ensureCached(ResourceType.GROUND, networkUuid, variantNum); + ensureCollectionCached(ResourceType.GROUND, networkUuid, variantNum); delegate.removeGrounds(networkUuid, variantNum, groundsId); } @Override public List> getVoltageLevelTwoWindingsTransformers(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.TWO_WINDINGS_TRANSFORMER, networkUuid, variantNum); + ensureCollectionCached(ResourceType.TWO_WINDINGS_TRANSFORMER, networkUuid, variantNum); return delegate.getVoltageLevelTwoWindingsTransformers(networkUuid, variantNum, voltageLevelId); } @Override public void removeTwoWindingsTransformers(UUID networkUuid, int variantNum, List twoWindingsTransformersId) { - ensureCached(ResourceType.TWO_WINDINGS_TRANSFORMER, networkUuid, variantNum); + ensureCollectionCached(ResourceType.TWO_WINDINGS_TRANSFORMER, networkUuid, variantNum); delegate.removeTwoWindingsTransformers(networkUuid, variantNum, twoWindingsTransformersId); } @Override public List> getVoltageLevelThreeWindingsTransformers(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.THREE_WINDINGS_TRANSFORMER, networkUuid, variantNum); + ensureCollectionCached(ResourceType.THREE_WINDINGS_TRANSFORMER, networkUuid, variantNum); return delegate.getVoltageLevelThreeWindingsTransformers(networkUuid, variantNum, voltageLevelId); } @Override public void removeThreeWindingsTransformers(UUID networkUuid, int variantNum, List threeWindingsTransformersId) { - ensureCached(ResourceType.THREE_WINDINGS_TRANSFORMER, networkUuid, variantNum); + ensureCollectionCached(ResourceType.THREE_WINDINGS_TRANSFORMER, networkUuid, variantNum); delegate.removeThreeWindingsTransformers(networkUuid, variantNum, threeWindingsTransformersId); } @Override public List> getVoltageLevelLines(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.LINE, networkUuid, variantNum); + ensureCollectionCached(ResourceType.LINE, networkUuid, variantNum); return delegate.getVoltageLevelLines(networkUuid, variantNum, voltageLevelId); } @Override public void removeLines(UUID networkUuid, int variantNum, List linesId) { - ensureCached(ResourceType.LINE, networkUuid, variantNum); + ensureCollectionCached(ResourceType.LINE, networkUuid, variantNum); delegate.removeLines(networkUuid, variantNum, linesId); } @Override public List> getVoltageLevelDanglingLines(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.DANGLING_LINE, networkUuid, variantNum); + ensureCollectionCached(ResourceType.DANGLING_LINE, networkUuid, variantNum); return delegate.getVoltageLevelDanglingLines(networkUuid, variantNum, voltageLevelId); } @Override public void createSwitches(UUID networkUuid, List> switchResources) { for (Resource switchResource : switchResources) { - ensureCached(ResourceType.SWITCH, networkUuid, switchResource.getVariantNum()); + ensureCollectionCached(ResourceType.SWITCH, networkUuid, switchResource.getVariantNum()); } delegate.createSwitches(networkUuid, switchResources); } @Override public List> getSwitches(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.SWITCH, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.SWITCH, networkUuid, variantNum); return delegate.getSwitches(networkUuid, variantNum); } @Override public Optional> getSwitch(UUID networkUuid, int variantNum, String switchId) { - ensureCached(ResourceType.SWITCH, networkUuid, variantNum); + ensureCollectionCached(ResourceType.SWITCH, networkUuid, variantNum); return delegate.getSwitch(networkUuid, variantNum, switchId); } @Override public void updateSwitches(UUID networkUuid, List> switchResources, AttributeFilter attributeFilter) { for (Resource switchResource : switchResources) { - ensureCached(ResourceType.SWITCH, networkUuid, switchResource.getVariantNum()); + ensureCollectionCached(ResourceType.SWITCH, networkUuid, switchResource.getVariantNum()); } delegate.updateSwitches(networkUuid, switchResources, attributeFilter); } @Override public void removeSwitches(UUID networkUuid, int variantNum, List switchesId) { - ensureCached(ResourceType.SWITCH, networkUuid, variantNum); + ensureCollectionCached(ResourceType.SWITCH, networkUuid, variantNum); delegate.removeSwitches(networkUuid, variantNum, switchesId); } @Override public void createBusbarSections(UUID networkUuid, List> busbarSectionResources) { for (Resource busbarSectionResource : busbarSectionResources) { - ensureCached(ResourceType.BUSBAR_SECTION, networkUuid, busbarSectionResource.getVariantNum()); + ensureCollectionCached(ResourceType.BUSBAR_SECTION, networkUuid, busbarSectionResource.getVariantNum()); } delegate.createBusbarSections(networkUuid, busbarSectionResources); } @Override public List> getBusbarSections(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.BUSBAR_SECTION, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.BUSBAR_SECTION, networkUuid, variantNum); return delegate.getBusbarSections(networkUuid, variantNum); } @Override public Optional> getBusbarSection(UUID networkUuid, int variantNum, String busbarSectionId) { - ensureCached(ResourceType.BUSBAR_SECTION, networkUuid, variantNum); + ensureCollectionCached(ResourceType.BUSBAR_SECTION, networkUuid, variantNum); return delegate.getBusbarSection(networkUuid, variantNum, busbarSectionId); } @Override public void updateBusbarSections(UUID networkUuid, List> busbarSectionResources, AttributeFilter attributeFilter) { for (Resource busbarSectionResource : busbarSectionResources) { - ensureCached(ResourceType.BUSBAR_SECTION, networkUuid, busbarSectionResource.getVariantNum()); + ensureCollectionCached(ResourceType.BUSBAR_SECTION, networkUuid, busbarSectionResource.getVariantNum()); } delegate.updateBusbarSections(networkUuid, busbarSectionResources, attributeFilter); } @@ -423,27 +425,27 @@ public void updateBusbarSections(UUID networkUuid, List> loadResources) { for (Resource loadResource : loadResources) { - ensureCached(ResourceType.LOAD, networkUuid, loadResource.getVariantNum()); + ensureCollectionCached(ResourceType.LOAD, networkUuid, loadResource.getVariantNum()); } delegate.createLoads(networkUuid, loadResources); } @Override public List> getLoads(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.LOAD, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.LOAD, networkUuid, variantNum); return delegate.getLoads(networkUuid, variantNum); } @Override public Optional> getLoad(UUID networkUuid, int variantNum, String loadId) { - ensureCached(ResourceType.LOAD, networkUuid, variantNum); + ensureCollectionCached(ResourceType.LOAD, networkUuid, variantNum); return delegate.getLoad(networkUuid, variantNum, loadId); } @Override public void updateLoads(UUID networkUuid, List> loadResources, AttributeFilter attributeFilter) { for (Resource loadResource : loadResources) { - ensureCached(ResourceType.LOAD, networkUuid, loadResource.getVariantNum()); + ensureCollectionCached(ResourceType.LOAD, networkUuid, loadResource.getVariantNum()); } delegate.updateLoads(networkUuid, loadResources, attributeFilter); } @@ -451,27 +453,27 @@ public void updateLoads(UUID networkUuid, List> loadRes @Override public void createGenerators(UUID networkUuid, List> generatorResources) { for (Resource generatorResource : generatorResources) { - ensureCached(ResourceType.GENERATOR, networkUuid, generatorResource.getVariantNum()); + ensureCollectionCached(ResourceType.GENERATOR, networkUuid, generatorResource.getVariantNum()); } delegate.createGenerators(networkUuid, generatorResources); } @Override public List> getGenerators(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.GENERATOR, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.GENERATOR, networkUuid, variantNum); return delegate.getGenerators(networkUuid, variantNum); } @Override public Optional> getGenerator(UUID networkUuid, int variantNum, String generatorId) { - ensureCached(ResourceType.GENERATOR, networkUuid, variantNum); + ensureCollectionCached(ResourceType.GENERATOR, networkUuid, variantNum); return delegate.getGenerator(networkUuid, variantNum, generatorId); } @Override public void updateGenerators(UUID networkUuid, List> generatorResources, AttributeFilter attributeFilter) { for (Resource generatorResource : generatorResources) { - ensureCached(ResourceType.GENERATOR, networkUuid, generatorResource.getVariantNum()); + ensureCollectionCached(ResourceType.GENERATOR, networkUuid, generatorResource.getVariantNum()); } delegate.updateGenerators(networkUuid, generatorResources, attributeFilter); } @@ -479,27 +481,27 @@ public void updateGenerators(UUID networkUuid, List> batteryResources) { for (Resource batteryResource : batteryResources) { - ensureCached(ResourceType.BATTERY, networkUuid, batteryResource.getVariantNum()); + ensureCollectionCached(ResourceType.BATTERY, networkUuid, batteryResource.getVariantNum()); } delegate.createBatteries(networkUuid, batteryResources); } @Override public List> getBatteries(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.BATTERY, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.BATTERY, networkUuid, variantNum); return delegate.getBatteries(networkUuid, variantNum); } @Override public Optional> getBattery(UUID networkUuid, int variantNum, String batteryId) { - ensureCached(ResourceType.BATTERY, networkUuid, variantNum); + ensureCollectionCached(ResourceType.BATTERY, networkUuid, variantNum); return delegate.getBattery(networkUuid, variantNum, batteryId); } @Override public void updateBatteries(UUID networkUuid, List> batteryResources, AttributeFilter attributeFilter) { for (Resource batteryResource : batteryResources) { - ensureCached(ResourceType.BATTERY, networkUuid, batteryResource.getVariantNum()); + ensureCollectionCached(ResourceType.BATTERY, networkUuid, batteryResource.getVariantNum()); } delegate.updateBatteries(networkUuid, batteryResources, attributeFilter); } @@ -507,27 +509,27 @@ public void updateBatteries(UUID networkUuid, List> @Override public void createGrounds(UUID networkUuid, List> groundResources) { for (Resource groundResource : groundResources) { - ensureCached(ResourceType.GROUND, networkUuid, groundResource.getVariantNum()); + ensureCollectionCached(ResourceType.GROUND, networkUuid, groundResource.getVariantNum()); } delegate.createGrounds(networkUuid, groundResources); } @Override public List> getGrounds(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.GROUND, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.GROUND, networkUuid, variantNum); return delegate.getGrounds(networkUuid, variantNum); } @Override public Optional> getGround(UUID networkUuid, int variantNum, String groundId) { - ensureCached(ResourceType.GROUND, networkUuid, variantNum); + ensureCollectionCached(ResourceType.GROUND, networkUuid, variantNum); return delegate.getGround(networkUuid, variantNum, groundId); } @Override public void updateGrounds(UUID networkUuid, List> groundResources, AttributeFilter attributeFilter) { for (Resource groundResource : groundResources) { - ensureCached(ResourceType.GROUND, networkUuid, groundResource.getVariantNum()); + ensureCollectionCached(ResourceType.GROUND, networkUuid, groundResource.getVariantNum()); } delegate.updateGrounds(networkUuid, groundResources, attributeFilter); } @@ -535,27 +537,27 @@ public void updateGrounds(UUID networkUuid, List> gro @Override public void createTwoWindingsTransformers(UUID networkUuid, List> twoWindingsTransformerResources) { for (Resource twoWindingsTransformerResource : twoWindingsTransformerResources) { - ensureCached(ResourceType.TWO_WINDINGS_TRANSFORMER, networkUuid, twoWindingsTransformerResource.getVariantNum()); + ensureCollectionCached(ResourceType.TWO_WINDINGS_TRANSFORMER, networkUuid, twoWindingsTransformerResource.getVariantNum()); } delegate.createTwoWindingsTransformers(networkUuid, twoWindingsTransformerResources); } @Override public List> getTwoWindingsTransformers(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.TWO_WINDINGS_TRANSFORMER, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.TWO_WINDINGS_TRANSFORMER, networkUuid, variantNum); return delegate.getTwoWindingsTransformers(networkUuid, variantNum); } @Override public Optional> getTwoWindingsTransformer(UUID networkUuid, int variantNum, String twoWindingsTransformerId) { - ensureCached(ResourceType.TWO_WINDINGS_TRANSFORMER, networkUuid, variantNum); + ensureCollectionCached(ResourceType.TWO_WINDINGS_TRANSFORMER, networkUuid, variantNum); return delegate.getTwoWindingsTransformer(networkUuid, variantNum, twoWindingsTransformerId); } @Override public void updateTwoWindingsTransformers(UUID networkUuid, List> twoWindingsTransformerResources, AttributeFilter attributeFilter) { for (Resource twoWindingsTransformerResource : twoWindingsTransformerResources) { - ensureCached(ResourceType.TWO_WINDINGS_TRANSFORMER, networkUuid, twoWindingsTransformerResource.getVariantNum()); + ensureCollectionCached(ResourceType.TWO_WINDINGS_TRANSFORMER, networkUuid, twoWindingsTransformerResource.getVariantNum()); } delegate.updateTwoWindingsTransformers(networkUuid, twoWindingsTransformerResources, attributeFilter); } @@ -565,27 +567,27 @@ public void updateTwoWindingsTransformers(UUID networkUuid, List> threeWindingsTransformerResources) { for (Resource threeWindingsTransformerResource : threeWindingsTransformerResources) { - ensureCached(ResourceType.THREE_WINDINGS_TRANSFORMER, networkUuid, threeWindingsTransformerResource.getVariantNum()); + ensureCollectionCached(ResourceType.THREE_WINDINGS_TRANSFORMER, networkUuid, threeWindingsTransformerResource.getVariantNum()); } delegate.createThreeWindingsTransformers(networkUuid, threeWindingsTransformerResources); } @Override public List> getThreeWindingsTransformers(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.THREE_WINDINGS_TRANSFORMER, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.THREE_WINDINGS_TRANSFORMER, networkUuid, variantNum); return delegate.getThreeWindingsTransformers(networkUuid, variantNum); } @Override public Optional> getThreeWindingsTransformer(UUID networkUuid, int variantNum, String threeWindingsTransformerId) { - ensureCached(ResourceType.THREE_WINDINGS_TRANSFORMER, networkUuid, variantNum); + ensureCollectionCached(ResourceType.THREE_WINDINGS_TRANSFORMER, networkUuid, variantNum); return delegate.getThreeWindingsTransformer(networkUuid, variantNum, threeWindingsTransformerId); } @Override public void updateThreeWindingsTransformers(UUID networkUuid, List> threeWindingsTransformerResources, AttributeFilter attributeFilter) { for (Resource threeWindingsTransformerResource : threeWindingsTransformerResources) { - ensureCached(ResourceType.THREE_WINDINGS_TRANSFORMER, networkUuid, threeWindingsTransformerResource.getVariantNum()); + ensureCollectionCached(ResourceType.THREE_WINDINGS_TRANSFORMER, networkUuid, threeWindingsTransformerResource.getVariantNum()); } delegate.updateThreeWindingsTransformers(networkUuid, threeWindingsTransformerResources, attributeFilter); } @@ -593,27 +595,27 @@ public void updateThreeWindingsTransformers(UUID networkUuid, List> lineResources) { for (Resource lineResource : lineResources) { - ensureCached(ResourceType.LINE, networkUuid, lineResource.getVariantNum()); + ensureCollectionCached(ResourceType.LINE, networkUuid, lineResource.getVariantNum()); } delegate.createLines(networkUuid, lineResources); } @Override public List> getLines(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.LINE, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.LINE, networkUuid, variantNum); return delegate.getLines(networkUuid, variantNum); } @Override public Optional> getLine(UUID networkUuid, int variantNum, String lineId) { - ensureCached(ResourceType.LINE, networkUuid, variantNum); + ensureCollectionCached(ResourceType.LINE, networkUuid, variantNum); return delegate.getLine(networkUuid, variantNum, lineId); } @Override public void updateLines(UUID networkUuid, List> lineResources, AttributeFilter attributeFilter) { for (Resource lineResource : lineResources) { - ensureCached(ResourceType.LINE, networkUuid, lineResource.getVariantNum()); + ensureCollectionCached(ResourceType.LINE, networkUuid, lineResource.getVariantNum()); } delegate.updateLines(networkUuid, lineResources, attributeFilter); } @@ -621,27 +623,27 @@ public void updateLines(UUID networkUuid, List> lineRes @Override public void createShuntCompensators(UUID networkUuid, List> shuntCompensatorResources) { for (Resource shuntCompensatorResource : shuntCompensatorResources) { - ensureCached(ResourceType.SHUNT_COMPENSATOR, networkUuid, shuntCompensatorResource.getVariantNum()); + ensureCollectionCached(ResourceType.SHUNT_COMPENSATOR, networkUuid, shuntCompensatorResource.getVariantNum()); } delegate.createShuntCompensators(networkUuid, shuntCompensatorResources); } @Override public List> getShuntCompensators(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.SHUNT_COMPENSATOR, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.SHUNT_COMPENSATOR, networkUuid, variantNum); return delegate.getShuntCompensators(networkUuid, variantNum); } @Override public Optional> getShuntCompensator(UUID networkUuid, int variantNum, String shuntCompensatorId) { - ensureCached(ResourceType.SHUNT_COMPENSATOR, networkUuid, variantNum); + ensureCollectionCached(ResourceType.SHUNT_COMPENSATOR, networkUuid, variantNum); return delegate.getShuntCompensator(networkUuid, variantNum, shuntCompensatorId); } @Override public void updateShuntCompensators(UUID networkUuid, List> shuntCompensatorResources, AttributeFilter attributeFilter) { for (Resource shuntCompensatorResource : shuntCompensatorResources) { - ensureCached(ResourceType.SHUNT_COMPENSATOR, networkUuid, shuntCompensatorResource.getVariantNum()); + ensureCollectionCached(ResourceType.SHUNT_COMPENSATOR, networkUuid, shuntCompensatorResource.getVariantNum()); } delegate.updateShuntCompensators(networkUuid, shuntCompensatorResources, attributeFilter); } @@ -649,27 +651,27 @@ public void updateShuntCompensators(UUID networkUuid, List> vscConverterStationResources) { for (Resource vscConverterStationResource : vscConverterStationResources) { - ensureCached(ResourceType.VSC_CONVERTER_STATION, networkUuid, vscConverterStationResource.getVariantNum()); + ensureCollectionCached(ResourceType.VSC_CONVERTER_STATION, networkUuid, vscConverterStationResource.getVariantNum()); } delegate.createVscConverterStations(networkUuid, vscConverterStationResources); } @Override public List> getVscConverterStations(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.VSC_CONVERTER_STATION, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.VSC_CONVERTER_STATION, networkUuid, variantNum); return delegate.getVscConverterStations(networkUuid, variantNum); } @Override public Optional> getVscConverterStation(UUID networkUuid, int variantNum, String vscConverterStationId) { - ensureCached(ResourceType.VSC_CONVERTER_STATION, networkUuid, variantNum); + ensureCollectionCached(ResourceType.VSC_CONVERTER_STATION, networkUuid, variantNum); return delegate.getVscConverterStation(networkUuid, variantNum, vscConverterStationId); } @Override public void updateVscConverterStations(UUID networkUuid, List> vscConverterStationResources, AttributeFilter attributeFilter) { for (Resource vscConverterStationResource : vscConverterStationResources) { - ensureCached(ResourceType.VSC_CONVERTER_STATION, networkUuid, vscConverterStationResource.getVariantNum()); + ensureCollectionCached(ResourceType.VSC_CONVERTER_STATION, networkUuid, vscConverterStationResource.getVariantNum()); } delegate.updateVscConverterStations(networkUuid, vscConverterStationResources, attributeFilter); } @@ -677,27 +679,27 @@ public void updateVscConverterStations(UUID networkUuid, List> lccConverterStationResources) { for (Resource lccConverterStationResource : lccConverterStationResources) { - ensureCached(ResourceType.LCC_CONVERTER_STATION, networkUuid, lccConverterStationResource.getVariantNum()); + ensureCollectionCached(ResourceType.LCC_CONVERTER_STATION, networkUuid, lccConverterStationResource.getVariantNum()); } delegate.createLccConverterStations(networkUuid, lccConverterStationResources); } @Override public List> getLccConverterStations(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.LCC_CONVERTER_STATION, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.LCC_CONVERTER_STATION, networkUuid, variantNum); return delegate.getLccConverterStations(networkUuid, variantNum); } @Override public Optional> getLccConverterStation(UUID networkUuid, int variantNum, String lccConverterStationId) { - ensureCached(ResourceType.LCC_CONVERTER_STATION, networkUuid, variantNum); + ensureCollectionCached(ResourceType.LCC_CONVERTER_STATION, networkUuid, variantNum); return delegate.getLccConverterStation(networkUuid, variantNum, lccConverterStationId); } @Override public void updateLccConverterStations(UUID networkUuid, List> lccConverterStationResources, AttributeFilter attributeFilter) { for (Resource lccConverterStationResource : lccConverterStationResources) { - ensureCached(ResourceType.LCC_CONVERTER_STATION, networkUuid, lccConverterStationResource.getVariantNum()); + ensureCollectionCached(ResourceType.LCC_CONVERTER_STATION, networkUuid, lccConverterStationResource.getVariantNum()); } delegate.updateLccConverterStations(networkUuid, lccConverterStationResources, attributeFilter); } @@ -705,27 +707,27 @@ public void updateLccConverterStations(UUID networkUuid, List> svcResources) { for (Resource svcResource : svcResources) { - ensureCached(ResourceType.STATIC_VAR_COMPENSATOR, networkUuid, svcResource.getVariantNum()); + ensureCollectionCached(ResourceType.STATIC_VAR_COMPENSATOR, networkUuid, svcResource.getVariantNum()); } delegate.createStaticVarCompensators(networkUuid, svcResources); } @Override public List> getStaticVarCompensators(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.STATIC_VAR_COMPENSATOR, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.STATIC_VAR_COMPENSATOR, networkUuid, variantNum); return delegate.getStaticVarCompensators(networkUuid, variantNum); } @Override public Optional> getStaticVarCompensator(UUID networkUuid, int variantNum, String staticVarCompensatorId) { - ensureCached(ResourceType.STATIC_VAR_COMPENSATOR, networkUuid, variantNum); + ensureCollectionCached(ResourceType.STATIC_VAR_COMPENSATOR, networkUuid, variantNum); return delegate.getStaticVarCompensator(networkUuid, variantNum, staticVarCompensatorId); } @Override public void updateStaticVarCompensators(UUID networkUuid, List> svcResources, AttributeFilter attributeFilter) { for (Resource svcResource : svcResources) { - ensureCached(ResourceType.STATIC_VAR_COMPENSATOR, networkUuid, svcResource.getVariantNum()); + ensureCollectionCached(ResourceType.STATIC_VAR_COMPENSATOR, networkUuid, svcResource.getVariantNum()); } delegate.updateStaticVarCompensators(networkUuid, svcResources, attributeFilter); } @@ -733,33 +735,33 @@ public void updateStaticVarCompensators(UUID networkUuid, List> hvdcLineResources) { for (Resource hvdcLineResource : hvdcLineResources) { - ensureCached(ResourceType.HVDC_LINE, networkUuid, hvdcLineResource.getVariantNum()); + ensureCollectionCached(ResourceType.HVDC_LINE, networkUuid, hvdcLineResource.getVariantNum()); } delegate.createHvdcLines(networkUuid, hvdcLineResources); } @Override public List> getHvdcLines(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.HVDC_LINE, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.HVDC_LINE, networkUuid, variantNum); return delegate.getHvdcLines(networkUuid, variantNum); } @Override public Optional> getHvdcLine(UUID networkUuid, int variantNum, String hvdcLineId) { - ensureCached(ResourceType.HVDC_LINE, networkUuid, variantNum); + ensureCollectionCached(ResourceType.HVDC_LINE, networkUuid, variantNum); return delegate.getHvdcLine(networkUuid, variantNum, hvdcLineId); } @Override public void removeHvdcLines(UUID networkUuid, int variantNum, List hvdcLinesId) { - ensureCached(ResourceType.HVDC_LINE, networkUuid, variantNum); + ensureCollectionCached(ResourceType.HVDC_LINE, networkUuid, variantNum); delegate.removeHvdcLines(networkUuid, variantNum, hvdcLinesId); } @Override public void updateHvdcLines(UUID networkUuid, List> hvdcLineResources, AttributeFilter attributeFilter) { for (Resource hvdcLineResource : hvdcLineResources) { - ensureCached(ResourceType.HVDC_LINE, networkUuid, hvdcLineResource.getVariantNum()); + ensureCollectionCached(ResourceType.HVDC_LINE, networkUuid, hvdcLineResource.getVariantNum()); } delegate.updateHvdcLines(networkUuid, hvdcLineResources, attributeFilter); } @@ -767,67 +769,67 @@ public void updateHvdcLines(UUID networkUuid, List> @Override public void createDanglingLines(UUID networkUuid, List> danglingLineResources) { for (Resource danglingLineResource : danglingLineResources) { - ensureCached(ResourceType.DANGLING_LINE, networkUuid, danglingLineResource.getVariantNum()); + ensureCollectionCached(ResourceType.DANGLING_LINE, networkUuid, danglingLineResource.getVariantNum()); } delegate.createDanglingLines(networkUuid, danglingLineResources); } @Override public List> getDanglingLines(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.DANGLING_LINE, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.DANGLING_LINE, networkUuid, variantNum); return delegate.getDanglingLines(networkUuid, variantNum); } @Override public Optional> getDanglingLine(UUID networkUuid, int variantNum, String danglingLineId) { - ensureCached(ResourceType.DANGLING_LINE, networkUuid, variantNum); + ensureCollectionCached(ResourceType.DANGLING_LINE, networkUuid, variantNum); return delegate.getDanglingLine(networkUuid, variantNum, danglingLineId); } @Override public void updateDanglingLines(UUID networkUuid, List> danglingLineResources, AttributeFilter attributeFilter) { for (Resource danglingLineResource : danglingLineResources) { - ensureCached(ResourceType.DANGLING_LINE, networkUuid, danglingLineResource.getVariantNum()); + ensureCollectionCached(ResourceType.DANGLING_LINE, networkUuid, danglingLineResource.getVariantNum()); } delegate.updateDanglingLines(networkUuid, danglingLineResources, attributeFilter); } @Override public void removeDanglingLines(UUID networkUuid, int variantNum, List danglingLinesId) { - ensureCached(ResourceType.DANGLING_LINE, networkUuid, variantNum); + ensureCollectionCached(ResourceType.DANGLING_LINE, networkUuid, variantNum); delegate.removeDanglingLines(networkUuid, variantNum, danglingLinesId); } @Override public void createTieLines(UUID networkUuid, List> tieLineResources) { for (Resource tieLineResource : tieLineResources) { - ensureCached(ResourceType.TIE_LINE, networkUuid, tieLineResource.getVariantNum()); + ensureCollectionCached(ResourceType.TIE_LINE, networkUuid, tieLineResource.getVariantNum()); } delegate.createTieLines(networkUuid, tieLineResources); } @Override public List> getTieLines(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.TIE_LINE, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.TIE_LINE, networkUuid, variantNum); return delegate.getTieLines(networkUuid, variantNum); } @Override public Optional> getTieLine(UUID networkUuid, int variantNum, String tieLineId) { - ensureCached(ResourceType.TIE_LINE, networkUuid, variantNum); + ensureCollectionCached(ResourceType.TIE_LINE, networkUuid, variantNum); return delegate.getTieLine(networkUuid, variantNum, tieLineId); } @Override public void removeTieLines(UUID networkUuid, int variantNum, List tieLinesId) { - ensureCached(ResourceType.TIE_LINE, networkUuid, variantNum); + ensureCollectionCached(ResourceType.TIE_LINE, networkUuid, variantNum); delegate.removeTieLines(networkUuid, variantNum, tieLinesId); } @Override public void updateTieLines(UUID networkUuid, List> tieLineResources, AttributeFilter attributeFilter) { for (Resource tieLineResource : tieLineResources) { - ensureCached(ResourceType.TIE_LINE, networkUuid, tieLineResource.getVariantNum()); + ensureCollectionCached(ResourceType.TIE_LINE, networkUuid, tieLineResource.getVariantNum()); } delegate.updateTieLines(networkUuid, tieLineResources, attributeFilter); } @@ -835,52 +837,52 @@ public void updateTieLines(UUID networkUuid, List> t @Override public void createConfiguredBuses(UUID networkUuid, List> busResources) { for (Resource busResource : busResources) { - ensureCached(ResourceType.CONFIGURED_BUS, networkUuid, busResource.getVariantNum()); + ensureCollectionCached(ResourceType.CONFIGURED_BUS, networkUuid, busResource.getVariantNum()); } delegate.createConfiguredBuses(networkUuid, busResources); } @Override public List> getConfiguredBuses(UUID networkUuid, int variantNum) { - ensureCached(ResourceType.CONFIGURED_BUS, networkUuid, variantNum); + ensureAllCollectionForBusViewCached(ResourceType.CONFIGURED_BUS, networkUuid, variantNum); return delegate.getConfiguredBuses(networkUuid, variantNum); } @Override public List> getVoltageLevelConfiguredBuses(UUID networkUuid, int variantNum, String voltageLevelId) { - ensureCached(ResourceType.CONFIGURED_BUS, networkUuid, variantNum); + ensureCollectionCached(ResourceType.CONFIGURED_BUS, networkUuid, variantNum); return delegate.getVoltageLevelConfiguredBuses(networkUuid, variantNum, voltageLevelId); } @Override public Optional> getConfiguredBus(UUID networkUuid, int variantNum, String busId) { - ensureCached(ResourceType.CONFIGURED_BUS, networkUuid, variantNum); + ensureCollectionCached(ResourceType.CONFIGURED_BUS, networkUuid, variantNum); return delegate.getConfiguredBus(networkUuid, variantNum, busId); } @Override public void updateConfiguredBuses(UUID networkUuid, List> busResources, AttributeFilter attributeFilter) { for (Resource busResource : busResources) { - ensureCached(ResourceType.CONFIGURED_BUS, networkUuid, busResource.getVariantNum()); + ensureCollectionCached(ResourceType.CONFIGURED_BUS, networkUuid, busResource.getVariantNum()); } delegate.updateConfiguredBuses(networkUuid, busResources, attributeFilter); } @Override public void removeConfiguredBuses(UUID networkUuid, int variantNum, List configuredBusesId) { - ensureCached(ResourceType.CONFIGURED_BUS, networkUuid, variantNum); + ensureCollectionCached(ResourceType.CONFIGURED_BUS, networkUuid, variantNum); delegate.removeConfiguredBuses(networkUuid, variantNum, configuredBusesId); } @Override public Optional getExtensionAttributes(UUID networkUuid, int variantNum, ResourceType resourceType, String identifiableId, String extensionName) { - delegate.getAllExtensionsAttributesByResourceTypeAndExtensionName(networkUuid, variantNum, resourceType, extensionName); + delegate.loadAllExtensionsAttributesByResourceTypeAndExtensionName(networkUuid, variantNum, resourceType, extensionName); return delegate.getExtensionAttributes(networkUuid, variantNum, resourceType, identifiableId, extensionName); } @Override public Map getAllExtensionsAttributesByIdentifiableId(UUID networkUuid, int variantNum, ResourceType resourceType, String id) { - delegate.getAllExtensionsAttributesByResourceType(networkUuid, variantNum, resourceType); + delegate.loadAllExtensionsAttributesByResourceType(networkUuid, variantNum, resourceType); return delegate.getAllExtensionsAttributesByIdentifiableId(networkUuid, variantNum, resourceType, id); } } diff --git a/network-store-client/src/test/java/com/powsybl/network/store/client/PreloadingAllCollectionsTest.java b/network-store-client/src/test/java/com/powsybl/network/store/client/PreloadingAllCollectionsTest.java index 3960aaf0a..8e0a8d0e3 100644 --- a/network-store-client/src/test/java/com/powsybl/network/store/client/PreloadingAllCollectionsTest.java +++ b/network-store-client/src/test/java/com/powsybl/network/store/client/PreloadingAllCollectionsTest.java @@ -6,11 +6,16 @@ */ package com.powsybl.network.store.client; +import com.powsybl.iidm.network.VariantManagerConstants; import com.powsybl.network.store.iidm.impl.CachedNetworkStoreClient; import com.powsybl.network.store.iidm.impl.OfflineNetworkStoreClient; +import com.powsybl.network.store.model.NetworkAttributes; +import com.powsybl.network.store.model.Resource; import com.powsybl.network.store.model.ResourceType; import org.junit.Test; +import java.time.ZonedDateTime; +import java.util.List; import java.util.UUID; import java.util.concurrent.ForkJoinPool; @@ -23,29 +28,39 @@ public class PreloadingAllCollectionsTest { @Test - public void test() { - var client = new PreloadingNetworkStoreClient(new CachedNetworkStoreClient(new OfflineNetworkStoreClient()), false, ForkJoinPool.commonPool()); + public void testWithAllCollections() { + var client = new PreloadingNetworkStoreClient(new CachedNetworkStoreClient(new OfflineNetworkStoreClient()), true, ForkJoinPool.commonPool()); UUID networkUuid = UUID.fromString("7928181c-7977-4592-ba19-88027e4254e4"); + assertTrue(client.shouldLoadAllCollectionsNeededForBusView(ResourceType.SUBSTATION)); client.getSubstations(networkUuid, 0); - assertTrue(client.isResourceTypeCached(networkUuid, 0, ResourceType.SUBSTATION)); - for (ResourceType resourceType : ResourceType.values()) { - if (resourceType != ResourceType.SUBSTATION) { - assertFalse(client.isResourceTypeCached(networkUuid, 0, ResourceType.GENERATOR)); - } - } + assertFalse(client.shouldLoadAllCollectionsNeededForBusView(ResourceType.SUBSTATION)); } @Test - public void testWithAllCollections() { + public void testWithAllCollectionsDeleteNetwork() { var client = new PreloadingNetworkStoreClient(new CachedNetworkStoreClient(new OfflineNetworkStoreClient()), true, ForkJoinPool.commonPool()); UUID networkUuid = UUID.fromString("7928181c-7977-4592-ba19-88027e4254e4"); + Resource n1 = Resource.networkBuilder() + .id("n1") + .attributes(NetworkAttributes.builder() + .uuid(networkUuid) + .variantId(VariantManagerConstants.INITIAL_VARIANT_ID) + .caseDate(ZonedDateTime.parse("2015-01-01T00:00:00.000Z")) + .build()) + .build(); + client.createNetworks(List.of(n1)); + assertTrue(client.shouldLoadAllCollectionsNeededForBusView(ResourceType.SUBSTATION)); + client.getSubstations(networkUuid, 0); + assertFalse(client.shouldLoadAllCollectionsNeededForBusView(ResourceType.SUBSTATION)); + // When we delete the network, we should load again all collection needed for bus view on next get + client.deleteNetwork(networkUuid); + assertTrue(client.shouldLoadAllCollectionsNeededForBusView(ResourceType.SUBSTATION)); + client.createNetworks(List.of(n1)); + assertTrue(client.shouldLoadAllCollectionsNeededForBusView(ResourceType.SUBSTATION)); client.getSubstations(networkUuid, 0); - for (ResourceType resourceType : ResourceType.values()) { - if (PreloadingNetworkStoreClient.RESOURCE_TYPES_NEEDED_FOR_BUS_VIEW.contains(resourceType)) { - assertTrue(client.isResourceTypeCached(networkUuid, 0, resourceType)); - } else { - assertFalse(client.isResourceTypeCached(networkUuid, 0, resourceType)); - } - } + assertFalse(client.shouldLoadAllCollectionsNeededForBusView(ResourceType.SUBSTATION)); + // When we delete the network variant, we should load again all collection needed for bus view on next get + client.deleteNetwork(networkUuid, 0); + assertTrue(client.shouldLoadAllCollectionsNeededForBusView(ResourceType.SUBSTATION)); } } diff --git a/network-store-client/src/test/java/com/powsybl/network/store/client/PreloadingNetworkStoreClientTest.java b/network-store-client/src/test/java/com/powsybl/network/store/client/PreloadingNetworkStoreClientTest.java index dbe87a1d2..31710dd78 100644 --- a/network-store-client/src/test/java/com/powsybl/network/store/client/PreloadingNetworkStoreClientTest.java +++ b/network-store-client/src/test/java/com/powsybl/network/store/client/PreloadingNetworkStoreClientTest.java @@ -102,6 +102,29 @@ public void testSubstationCache() throws IOException { assertEquals(1, cachedClient.getSubstations(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); cachedClient.removeSubstations(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("sub1")); assertEquals(0, cachedClient.getSubstations(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + + // Recreate substation + cachedClient.createSubstations(networkUuid, List.of(substation)); + List> substations = cachedClient.getSubstations(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, substations.size()); + assertNotNull(substations.get(0)); + assertEquals(Boolean.TRUE, substations.get(0).getAttributes().getName().equals("SUB1")); + + // Update substation + Resource updateSubstation = Resource.substationBuilder() + .id("sub1") + .attributes(SubstationAttributes.builder() + .country(Country.FR) + .tso("TSO_FR") + .name("SUB2") + .build()) + .build(); + cachedClient.updateSubstations(networkUuid, List.of(updateSubstation), null); + substations = cachedClient.getSubstations(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, substations.size()); + assertNotNull(substations.get(0)); + assertEquals(Boolean.TRUE, substations.get(0).getAttributes().getName().equals("SUB2")); + server.verify(); } @@ -139,6 +162,29 @@ public void testVoltageLevelCache() throws IOException { assertEquals(1, cachedClient.getVoltageLevels(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); cachedClient.removeVoltageLevels(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("vl1")); assertEquals(0, cachedClient.getVoltageLevels(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + + // Recreate voltage level + cachedClient.createVoltageLevels(networkUuid, List.of(vl)); + List> voltageLevels = cachedClient.getVoltageLevels(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, voltageLevels.size()); + assertNotNull(voltageLevels.get(0)); + assertEquals(Boolean.TRUE, voltageLevels.get(0).getAttributes().getName().equals("VL1")); + + // Update voltage level + Resource updateVl = Resource.voltageLevelBuilder() + .id("vl1") + .attributes(VoltageLevelAttributes.builder() + .name("VL2") + .lowVoltageLimit(100) + .highVoltageLimit(200) + .build()) + .build(); + cachedClient.updateVoltageLevels(networkUuid, List.of(updateVl), null); + voltageLevels = cachedClient.getVoltageLevels(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, voltageLevels.size()); + assertNotNull(voltageLevels.get(0)); + assertEquals(Boolean.TRUE, voltageLevels.get(0).getAttributes().getName().equals("VL2")); + server.verify(); } @@ -180,6 +226,34 @@ public void testSwitchCache() throws IOException { assertEquals(1, cachedClient.getSwitches(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); cachedClient.removeSwitches(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("b1")); assertEquals(0, cachedClient.getSwitches(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + + // Recreate switch + cachedClient.createSwitches(networkUuid, List.of(breaker)); + assertEquals(1, cachedClient.getVoltageLevelSwitches(networkUuid, Resource.INITIAL_VARIANT_NUM, "vl1").size()); + List> switches = cachedClient.getSwitches(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, switches.size()); + assertNotNull(switches.get(0)); + assertEquals(Boolean.FALSE, switches.get(0).getAttributes().isOpen()); + + // Update switch + Resource updateBreaker = Resource.switchBuilder() + .id("b1") + .attributes(SwitchAttributes.builder() + .voltageLevelId("vl1") + .kind(SwitchKind.BREAKER) + .node1(1) + .node2(2) + .open(true) + .retained(false) + .fictitious(false) + .build()) + .build(); + cachedClient.updateSwitches(networkUuid, List.of(updateBreaker), null); + switches = cachedClient.getSwitches(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, switches.size()); + assertNotNull(switches.get(0)); + assertEquals(Boolean.TRUE, switches.get(0).getAttributes().isOpen()); + server.verify(); } @@ -218,6 +292,29 @@ public void testGeneratorCache() throws IOException { cachedClient.removeGenerators(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("g1")); assertEquals(0, cachedClient.getGenerators(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + // Recreate generator + cachedClient.createGenerators(networkUuid, List.of(generator)); + assertEquals(1, cachedClient.getVoltageLevelGenerators(networkUuid, Resource.INITIAL_VARIANT_NUM, "vl1").size()); + List> generators = cachedClient.getGenerators(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, generators.size()); + assertNotNull(generators.get(0)); + assertEquals(200., generators.get(0).getAttributes().getP(), 0.001); + + // Update generator + Resource updateGenerator = Resource.generatorBuilder() + .id("g1") + .attributes(GeneratorAttributes.builder() + .voltageLevelId("vl1") + .name("g1") + .p(300.) + .build()) + .build(); + cachedClient.updateGenerators(networkUuid, List.of(updateGenerator), null); + generators = cachedClient.getGenerators(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, generators.size()); + assertNotNull(generators.get(0)); + assertEquals(300., generators.get(0).getAttributes().getP(), 0.001); + server.verify(); } @@ -260,6 +357,32 @@ public void testBatteryCache() throws IOException { cachedClient.removeBatteries(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("b1")); assertEquals(0, cachedClient.getBatteries(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + // Recreate battery + cachedClient.createBatteries(networkUuid, List.of(battery)); + assertEquals(1, cachedClient.getVoltageLevelBatteries(networkUuid, Resource.INITIAL_VARIANT_NUM, "vl1").size()); + List> batteries = cachedClient.getBatteries(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, batteries.size()); + assertNotNull(batteries.get(0)); + assertEquals(250., batteries.get(0).getAttributes().getP(), 0.001); + assertEquals(120., batteries.get(0).getAttributes().getQ(), 0.001); + + // Update battery + Resource updateBattery = Resource.batteryBuilder() + .id("b1") + .attributes(BatteryAttributes.builder() + .voltageLevelId("vl1") + .name("b1") + .p(300) + .q(150) + .build()) + .build(); + cachedClient.updateBatteries(networkUuid, List.of(updateBattery), null); + batteries = cachedClient.getBatteries(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, batteries.size()); + assertNotNull(batteries.get(0)); + assertEquals(300., batteries.get(0).getAttributes().getP(), 0.001); + assertEquals(150., batteries.get(0).getAttributes().getQ(), 0.001); + server.verify(); } @@ -302,6 +425,32 @@ public void testLoadCache() throws IOException { cachedClient.removeLoads(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("l1")); assertEquals(0, cachedClient.getLoads(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + // Recreate load + cachedClient.createLoads(networkUuid, List.of(load)); + assertEquals(1, cachedClient.getVoltageLevelLoads(networkUuid, Resource.INITIAL_VARIANT_NUM, "vl1").size()); + List> loads = cachedClient.getLoads(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, loads.size()); + assertNotNull(loads.get(0)); + assertEquals(LoadType.AUXILIARY, loads.get(0).getAttributes().getLoadType()); + assertEquals(100., loads.get(0).getAttributes().getP0(), 0.001); + + // Update battery + Resource updateLoad = Resource.loadBuilder() + .id("l1") + .attributes(LoadAttributes.builder() + .voltageLevelId("vl1") + .name("l1") + .loadType(LoadType.FICTITIOUS) + .p0(2000.) + .build()) + .build(); + cachedClient.updateLoads(networkUuid, List.of(updateLoad), null); + loads = cachedClient.getLoads(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, loads.size()); + assertNotNull(loads.get(0)); + assertEquals(LoadType.FICTITIOUS, loads.get(0).getAttributes().getLoadType()); + assertEquals(2000., loads.get(0).getAttributes().getP0(), 0.001); + server.verify(); } @@ -340,6 +489,29 @@ public void testShuntCompensatorCache() throws IOException { cachedClient.removeShuntCompensators(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("sc1")); assertEquals(0, cachedClient.getShuntCompensators(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + // Recreate shunt compensator + cachedClient.createShuntCompensators(networkUuid, List.of(shuntCompensator)); + assertEquals(1, cachedClient.getVoltageLevelShuntCompensators(networkUuid, Resource.INITIAL_VARIANT_NUM, "vl1").size()); + List> shuntCompensators = cachedClient.getShuntCompensators(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, shuntCompensators.size()); + assertNotNull(shuntCompensators.get(0)); + assertEquals(5, shuntCompensators.get(0).getAttributes().getSectionCount()); + + // Update shunt compensator + Resource updateShuntCompensator = Resource.shuntCompensatorBuilder() + .id("sc1") + .attributes(ShuntCompensatorAttributes.builder() + .voltageLevelId("vl1") + .name("sc1") + .sectionCount(8) + .build()) + .build(); + cachedClient.updateShuntCompensators(networkUuid, List.of(updateShuntCompensator), null); + shuntCompensators = cachedClient.getShuntCompensators(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, shuntCompensators.size()); + assertNotNull(shuntCompensators.get(0)); + assertEquals(8, shuntCompensators.get(0).getAttributes().getSectionCount()); + server.verify(); } @@ -382,6 +554,32 @@ public void testStaticVarCompensatorCache() throws IOException { cachedClient.removeStaticVarCompensators(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("svc1")); assertEquals(0, cachedClient.getStaticVarCompensators(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + // Recreate static var compensator + cachedClient.createStaticVarCompensators(networkUuid, List.of(staticVarCompensator)); + assertEquals(1, cachedClient.getVoltageLevelStaticVarCompensators(networkUuid, Resource.INITIAL_VARIANT_NUM, "vl1").size()); + List> staticVarCompensators = cachedClient.getStaticVarCompensators(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, staticVarCompensators.size()); + assertNotNull(staticVarCompensators.get(0)); + assertEquals(20., staticVarCompensators.get(0).getAttributes().getBmax(), 0.001); + assertEquals(100., staticVarCompensators.get(0).getAttributes().getReactivePowerSetPoint(), 0.001); + + // Update static var compensator + Resource updateStaticVarCompensator = Resource.staticVarCompensatorBuilder() + .id("svc1") + .attributes(StaticVarCompensatorAttributes.builder() + .voltageLevelId("vl1") + .name("svc1") + .bmax(50) + .reactivePowerSetPoint(1500) + .build()) + .build(); + cachedClient.updateStaticVarCompensators(networkUuid, List.of(updateStaticVarCompensator), null); + staticVarCompensators = cachedClient.getStaticVarCompensators(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, staticVarCompensators.size()); + assertNotNull(staticVarCompensators.get(0)); + assertEquals(50., staticVarCompensators.get(0).getAttributes().getBmax(), 0.001); + assertEquals(1500., staticVarCompensators.get(0).getAttributes().getReactivePowerSetPoint(), 0.001); + server.verify(); } @@ -420,6 +618,29 @@ public void testVscConverterStationCache() throws IOException { cachedClient.removeVscConverterStations(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("vsc1")); assertEquals(0, cachedClient.getVscConverterStations(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + // Recreate vsc converter station + cachedClient.createVscConverterStations(networkUuid, List.of(vscConverterStation)); + assertEquals(1, cachedClient.getVoltageLevelVscConverterStations(networkUuid, Resource.INITIAL_VARIANT_NUM, "vl1").size()); + List> vscConverterStations = cachedClient.getVscConverterStations(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, vscConverterStations.size()); + assertNotNull(vscConverterStations.get(0)); + assertEquals(0.6, vscConverterStations.get(0).getAttributes().getLossFactor(), 0.001); + + // Update vsc converter station + Resource updateVscConverterStation = Resource.vscConverterStationBuilder() + .id("vsc1") + .attributes(VscConverterStationAttributes.builder() + .voltageLevelId("vl1") + .name("vsc1") + .lossFactor(0.8F) + .build()) + .build(); + cachedClient.updateVscConverterStations(networkUuid, List.of(updateVscConverterStation), null); + vscConverterStations = cachedClient.getVscConverterStations(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, vscConverterStations.size()); + assertNotNull(vscConverterStations.get(0)); + assertEquals(0.8, vscConverterStations.get(0).getAttributes().getLossFactor(), 0.001); + server.verify(); } @@ -458,6 +679,29 @@ public void testLccConverterStationCache() throws IOException { cachedClient.removeLccConverterStations(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("lcc1")); assertEquals(0, cachedClient.getLccConverterStations(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + // Recreate lcc converter station + cachedClient.createLccConverterStations(networkUuid, List.of(lccConverterStation)); + assertEquals(1, cachedClient.getVoltageLevelLccConverterStations(networkUuid, Resource.INITIAL_VARIANT_NUM, "vl1").size()); + List> lccConverterStations = cachedClient.getLccConverterStations(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, lccConverterStations.size()); + assertNotNull(lccConverterStations.get(0)); + assertEquals(250., lccConverterStations.get(0).getAttributes().getPowerFactor(), 0.001); + + // Update lcc converter station + Resource updateLccConverterStation = Resource.lccConverterStationBuilder() + .id("lcc1") + .attributes(LccConverterStationAttributes.builder() + .voltageLevelId("vl1") + .name("lcc1") + .powerFactor(400) + .build()) + .build(); + cachedClient.updateLccConverterStations(networkUuid, List.of(updateLccConverterStation), null); + lccConverterStations = cachedClient.getLccConverterStations(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, lccConverterStations.size()); + assertNotNull(lccConverterStations.get(0)); + assertEquals(400., lccConverterStations.get(0).getAttributes().getPowerFactor(), 0.001); + server.verify(); } @@ -573,6 +817,32 @@ public void testTwoWindingsTransformerCache() throws IOException { cachedClient.removeTwoWindingsTransformers(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("tw1")); assertEquals(0, cachedClient.getTwoWindingsTransformers(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + // Recreate two windings transformer + cachedClient.createTwoWindingsTransformers(networkUuid, List.of(twoWindingsTransformer)); + assertEquals(1, cachedClient.getVoltageLevelTwoWindingsTransformers(networkUuid, Resource.INITIAL_VARIANT_NUM, "vl1").size()); + List> twoWindingsTransformers = cachedClient.getTwoWindingsTransformers(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, twoWindingsTransformers.size()); + assertNotNull(twoWindingsTransformers.get(0)); + assertEquals(2., twoWindingsTransformers.get(0).getAttributes().getR(), 0.001); + assertEquals(3., twoWindingsTransformers.get(0).getAttributes().getX(), 0.001); + + // Update two windings transformer + Resource updateTwoWindingsTransformer = Resource.twoWindingsTransformerBuilder() + .id("tw1") + .attributes(TwoWindingsTransformerAttributes.builder() + .voltageLevelId1("vl1") + .voltageLevelId2("vl2") + .r(5) + .x(9) + .build()) + .build(); + cachedClient.updateTwoWindingsTransformers(networkUuid, List.of(updateTwoWindingsTransformer), null); + twoWindingsTransformers = cachedClient.getTwoWindingsTransformers(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, twoWindingsTransformers.size()); + assertNotNull(twoWindingsTransformers.get(0)); + assertEquals(5., twoWindingsTransformers.get(0).getAttributes().getR(), 0.001); + assertEquals(9., twoWindingsTransformers.get(0).getAttributes().getX(), 0.001); + server.verify(); } @@ -625,6 +895,42 @@ public void testThreeWindingsTransformerCache() throws IOException { cachedClient.removeThreeWindingsTransformers(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("tw1")); assertEquals(0, cachedClient.getThreeWindingsTransformers(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + // Recreate two windings transformer + cachedClient.createThreeWindingsTransformers(networkUuid, List.of(threeWindingsTransformer)); + assertEquals(1, cachedClient.getVoltageLevelThreeWindingsTransformers(networkUuid, Resource.INITIAL_VARIANT_NUM, "vl1").size()); + List> threeWindingsTransformers = cachedClient.getThreeWindingsTransformers(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, threeWindingsTransformers.size()); + assertNotNull(threeWindingsTransformers.get(0)); + assertEquals(50., threeWindingsTransformers.get(0).getAttributes().getP2(), 0.001); + assertEquals(60., threeWindingsTransformers.get(0).getAttributes().getQ3(), 0.001); + + // Update two windings transformer + Resource updateThreeWindingsTransformer = Resource.threeWindingsTransformerBuilder() + .id("tw1") + .attributes(ThreeWindingsTransformerAttributes.builder() + .leg1(LegAttributes.builder() + .legNumber(1) + .voltageLevelId("vl1") + .build()) + .leg2(LegAttributes.builder() + .legNumber(2) + .voltageLevelId("vl2") + .build()) + .p2(200) + .leg3(LegAttributes.builder() + .legNumber(3) + .voltageLevelId("vl3") + .build()) + .q3(550) + .build()) + .build(); + cachedClient.updateThreeWindingsTransformers(networkUuid, List.of(updateThreeWindingsTransformer), null); + threeWindingsTransformers = cachedClient.getThreeWindingsTransformers(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, threeWindingsTransformers.size()); + assertNotNull(threeWindingsTransformers.get(0)); + assertEquals(200., threeWindingsTransformers.get(0).getAttributes().getP2(), 0.001); + assertEquals(550., threeWindingsTransformers.get(0).getAttributes().getQ3(), 0.001); + server.verify(); } @@ -664,6 +970,30 @@ public void testLineCache() throws IOException { cachedClient.removeLines(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("l1")); assertEquals(0, cachedClient.getLines(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + // Recreate line + cachedClient.createLines(networkUuid, List.of(line)); + assertEquals(1, cachedClient.getVoltageLevelLines(networkUuid, Resource.INITIAL_VARIANT_NUM, "vl1").size()); + List> lines = cachedClient.getLines(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, lines.size()); + assertNotNull(lines.get(0)); + assertEquals(50., lines.get(0).getAttributes().getP1(), 0.001); + + // Update line + Resource updateLine = Resource.lineBuilder() + .id("l1") + .attributes(LineAttributes.builder() + .voltageLevelId1("vl1") + .voltageLevelId2("vl2") + .name("l1") + .p1(1000) + .build()) + .build(); + cachedClient.updateLines(networkUuid, List.of(updateLine), null); + lines = cachedClient.getLines(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, lines.size()); + assertNotNull(lines.get(0)); + assertEquals(1000., lines.get(0).getAttributes().getP1(), 0.001); + server.verify(); } @@ -697,9 +1027,35 @@ public void testHvdcLineCache() throws IOException { hvdcLineAttributesResource = cachedClient.getHvdcLine(networkUuid, Resource.INITIAL_VARIANT_NUM, "hvdc1").orElse(null); assertNotNull(hvdcLineAttributesResource); assertEquals(3000., hvdcLineAttributesResource.getAttributes().getMaxP(), 0.001); + + // Remove component assertEquals(1, cachedClient.getHvdcLines(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); cachedClient.removeHvdcLines(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("hvdc1")); assertEquals(0, cachedClient.getHvdcLines(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + + // Recreate line + cachedClient.createHvdcLines(networkUuid, List.of(hvdcLine)); + List> hvdcLines = cachedClient.getHvdcLines(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, hvdcLines.size()); + assertNotNull(hvdcLines.get(0)); + assertEquals(1000., hvdcLines.get(0).getAttributes().getMaxP(), 0.001); + + // Update line + Resource updateHvdcLine = Resource.hvdcLineBuilder() + .id("hvdc1") + .attributes(HvdcLineAttributes.builder() + .converterStationId1("c1") + .converterStationId2("c2") + .name("hvdc1") + .maxP(3000) + .build()) + .build(); + cachedClient.updateHvdcLines(networkUuid, List.of(updateHvdcLine), null); + hvdcLines = cachedClient.getHvdcLines(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, hvdcLines.size()); + assertNotNull(hvdcLines.get(0)); + assertEquals(3000., hvdcLines.get(0).getAttributes().getMaxP(), 0.001); + server.verify(); } @@ -733,6 +1089,33 @@ public void testDanglingLineCache() throws IOException { assertNotNull(danglingLineAttributesResource); assertEquals(60., danglingLineAttributesResource.getAttributes().getQ0(), 0.001); + // Remove component + assertEquals(1, cachedClient.getDanglingLines(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + cachedClient.removeDanglingLines(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("dl1")); + assertEquals(0, cachedClient.getDanglingLines(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + + // Recreate line + cachedClient.createDanglingLines(networkUuid, List.of(danglingLine)); + List> danglingLines = cachedClient.getDanglingLines(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, danglingLines.size()); + assertNotNull(danglingLines.get(0)); + assertEquals(10., danglingLines.get(0).getAttributes().getQ0(), 0.001); + + // Update line + Resource updateDanglingLine = Resource.danglingLineBuilder() + .id("dl1") + .attributes(DanglingLineAttributes.builder() + .voltageLevelId("vl1") + .name("dl1") + .q0(60) + .build()) + .build(); + cachedClient.updateDanglingLines(networkUuid, List.of(updateDanglingLine), null); + danglingLines = cachedClient.getDanglingLines(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, danglingLines.size()); + assertNotNull(danglingLines.get(0)); + assertEquals(60., danglingLines.get(0).getAttributes().getQ0(), 0.001); + server.verify(); } @@ -771,6 +1154,28 @@ public void testTieLineCache() throws IOException { cachedClient.removeTieLines(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("tieLine1")); assertEquals(0, cachedClient.getTieLines(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + // Recreate line + cachedClient.createTieLines(networkUuid, List.of(tieLine)); + List> tieLines = cachedClient.getTieLines(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, tieLines.size()); + assertNotNull(tieLines.get(0)); + assertEquals("dl1", tieLines.get(0).getAttributes().getDanglingLine1Id()); + + // Update line + Resource updateTieLine = Resource.tieLineBuilder() + .id("tieLine1") + .attributes(TieLineAttributes.builder() + .name("tieLine1") + .danglingLine1Id("dll1") + .danglingLine2Id("dl2") + .build()) + .build(); + cachedClient.updateTieLines(networkUuid, List.of(updateTieLine), null); + tieLines = cachedClient.getTieLines(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, tieLines.size()); + assertNotNull(tieLines.get(0)); + assertEquals("dll1", tieLines.get(0).getAttributes().getDanglingLine1Id()); + server.verify(); } @@ -804,9 +1209,34 @@ public void testConfiguredBusCache() throws IOException { assertNotNull(configuredBusAttributesResource); assertEquals(5., configuredBusAttributesResource.getAttributes().getAngle(), 0.001); + // Remove component assertEquals(1, cachedClient.getConfiguredBuses(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); cachedClient.removeConfiguredBuses(networkUuid, Resource.INITIAL_VARIANT_NUM, Collections.singletonList("cb1")); assertEquals(0, cachedClient.getConfiguredBuses(networkUuid, Resource.INITIAL_VARIANT_NUM).size()); + + // Recreate line + cachedClient.createConfiguredBuses(networkUuid, List.of(configuredBus)); + assertEquals(1, cachedClient.getVoltageLevelConfiguredBuses(networkUuid, Resource.INITIAL_VARIANT_NUM, "vl1").size()); + List> configuredBuses = cachedClient.getConfiguredBuses(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, configuredBuses.size()); + assertNotNull(configuredBuses.get(0)); + assertEquals(3., configuredBuses.get(0).getAttributes().getAngle(), 0.001); + + // Update line + Resource updateConfiguredBus = Resource.configuredBusBuilder() + .id("cb1") + .attributes(ConfiguredBusAttributes.builder() + .voltageLevelId("vl1") + .name("cb1") + .angle(5) + .build()) + .build(); + cachedClient.updateConfiguredBuses(networkUuid, List.of(updateConfiguredBus), null); + configuredBuses = cachedClient.getConfiguredBuses(networkUuid, Resource.INITIAL_VARIANT_NUM); + assertEquals(1, configuredBuses.size()); + assertNotNull(configuredBuses.get(0)); + assertEquals(5., configuredBuses.get(0).getAttributes().getAngle(), 0.001); + server.verify(); } @@ -997,7 +1427,7 @@ public void testGetExtensionsCacheWithClonedNetwork() throws IOException { server.expect(ExpectedCount.once(), requestTo("/networks/" + networkUuid + "/" + Resource.INITIAL_VARIANT_NUM + "/identifiables/types/" + ResourceType.GENERATOR + "/extensions")) .andExpect(method(GET)) .andRespond(withSuccess(multipleExtensionAttributes, MediaType.APPLICATION_JSON)); - cachedClient.getAllExtensionsAttributesByResourceType(networkUuid, Resource.INITIAL_VARIANT_NUM, ResourceType.GENERATOR); + cachedClient.getAllExtensionsAttributesByIdentifiableId(networkUuid, Resource.INITIAL_VARIANT_NUM, ResourceType.GENERATOR, identifiableId1); server.verify(); server.reset(); @@ -1008,9 +1438,8 @@ public void testGetExtensionsCacheWithClonedNetwork() throws IOException { cachedClient.cloneNetwork(networkUuid, Resource.INITIAL_VARIANT_NUM, targetVariantNum, targetVariantId); // Verify that the cache is copied and there is no new fetch - cachedClient.getAllExtensionsAttributesByResourceType(networkUuid, targetVariantNum, ResourceType.GENERATOR); - Map extensionAttributesByExtensionNameMap = cachedClient.getAllExtensionsAttributesByIdentifiableId(networkUuid, targetVariantNum, ResourceType.GENERATOR, identifiableId1); - assertEquals(2, extensionAttributesByExtensionNameMap.size()); + Map extensionAttributesByIdentifiableId = cachedClient.getAllExtensionsAttributesByIdentifiableId(networkUuid, targetVariantNum, ResourceType.GENERATOR, identifiableId1); + assertEquals(2, extensionAttributesByIdentifiableId.size()); server.verify(); server.reset(); } diff --git a/network-store-iidm-impl/src/main/java/com/powsybl/network/store/iidm/impl/AbstractForwardingNetworkStoreClient.java b/network-store-iidm-impl/src/main/java/com/powsybl/network/store/iidm/impl/AbstractForwardingNetworkStoreClient.java index f71674899..004b2fd08 100644 --- a/network-store-iidm-impl/src/main/java/com/powsybl/network/store/iidm/impl/AbstractForwardingNetworkStoreClient.java +++ b/network-store-iidm-impl/src/main/java/com/powsybl/network/store/iidm/impl/AbstractForwardingNetworkStoreClient.java @@ -13,12 +13,12 @@ /** * @author Geoffroy Jamgotchian */ -public abstract class AbstractForwardingNetworkStoreClient implements NetworkStoreClient { +public abstract class AbstractForwardingNetworkStoreClient implements NetworkStoreClient { - @Delegate - protected final NetworkStoreClient delegate; + @Delegate(types = NetworkStoreClient.class) + protected final T delegate; - protected AbstractForwardingNetworkStoreClient(NetworkStoreClient delegate) { + protected AbstractForwardingNetworkStoreClient(T delegate) { this.delegate = Objects.requireNonNull(delegate); } } diff --git a/network-store-iidm-impl/src/main/java/com/powsybl/network/store/iidm/impl/CachedNetworkStoreClient.java b/network-store-iidm-impl/src/main/java/com/powsybl/network/store/iidm/impl/CachedNetworkStoreClient.java index 12f5c53d0..f2526aed5 100644 --- a/network-store-iidm-impl/src/main/java/com/powsybl/network/store/iidm/impl/CachedNetworkStoreClient.java +++ b/network-store-iidm-impl/src/main/java/com/powsybl/network/store/iidm/impl/CachedNetworkStoreClient.java @@ -23,7 +23,7 @@ * @author Nicolas Noir * @author Etienne Homer */ -public class CachedNetworkStoreClient extends AbstractForwardingNetworkStoreClient implements NetworkStoreClient { +public class CachedNetworkStoreClient extends AbstractForwardingNetworkStoreClient implements NetworkStoreClient { private static final int MAX_GET_IDENTIFIABLE_CALL_COUNT = 10; @@ -1082,9 +1082,8 @@ public Optional getExtensionAttributes(UUID networkUuid, in return getCache(resourceType).getCollection(networkUuid, variantNum).getExtensionAttributes(networkUuid, variantNum, resourceType, identifiableId, extensionName); } - @Override - public Map getAllExtensionsAttributesByResourceTypeAndExtensionName(UUID networkUuid, int variantNum, ResourceType resourceType, String extensionName) { - return getCache(resourceType).getCollection(networkUuid, variantNum).getAllExtensionsAttributesByResourceTypeAndExtensionName(networkUuid, variantNum, resourceType, extensionName); + public void loadAllExtensionsAttributesByResourceTypeAndExtensionName(UUID networkUuid, int variantNum, ResourceType resourceType, String extensionName) { + getCache(resourceType).getCollection(networkUuid, variantNum).loadAllExtensionsAttributesByResourceTypeAndExtensionName(networkUuid, variantNum, resourceType, extensionName); } @Override @@ -1092,9 +1091,8 @@ public Map getAllExtensionsAttributesByIdentifiable return getCache(resourceType).getCollection(networkUuid, variantNum).getAllExtensionsAttributesByIdentifiableId(networkUuid, variantNum, resourceType, identifiableId); } - @Override - public Map> getAllExtensionsAttributesByResourceType(UUID networkUuid, int variantNum, ResourceType resourceType) { - return getCache(resourceType).getCollection(networkUuid, variantNum).getAllExtensionsAttributesByResourceType(networkUuid, variantNum, resourceType); + public void loadAllExtensionsAttributesByResourceType(UUID networkUuid, int variantNum, ResourceType resourceType) { + getCache(resourceType).getCollection(networkUuid, variantNum).loadAllExtensionsAttributesByResourceType(networkUuid, variantNum, resourceType); } @Override diff --git a/network-store-iidm-impl/src/main/java/com/powsybl/network/store/iidm/impl/CollectionCache.java b/network-store-iidm-impl/src/main/java/com/powsybl/network/store/iidm/impl/CollectionCache.java index a43a53e49..f1b301e51 100644 --- a/network-store-iidm-impl/src/main/java/com/powsybl/network/store/iidm/impl/CollectionCache.java +++ b/network-store-iidm-impl/src/main/java/com/powsybl/network/store/iidm/impl/CollectionCache.java @@ -430,9 +430,9 @@ private void addExtensionAttributesToCache(String identifiableId, String extensi } /** - * Get the extensions attributes with specified extension name for all the identifiables of the collection in the cache. + * Load all the extensions attributes with specified extension name for all the identifiables of the collection in the cache. */ - public Map getAllExtensionsAttributesByResourceTypeAndExtensionName(UUID networkUuid, int variantNum, ResourceType type, String extensionName) { + public void loadAllExtensionsAttributesByResourceTypeAndExtensionName(UUID networkUuid, int variantNum, ResourceType type, String extensionName) { if (!isFullyLoadedExtension(extensionName)) { // if collection has not yet been fully loaded we load it from the server Map extensionAttributesMap = delegate.getAllExtensionsAttributesByResourceTypeAndExtensionName(networkUuid, variantNum, type, extensionName); @@ -441,13 +441,6 @@ public Map getAllExtensionsAttributesByResourceType extensionAttributesMap.forEach((identifiableId, extensionAttributes) -> addExtensionAttributesToCache(identifiableId, extensionName, extensionAttributes)); fullyLoadedExtensionsByExtensionName.add(extensionName); } - //TODO This method is only used to load extension attributes in the collection cache when using preloading collection. - // The return is never used by the client as the call to getAllExtensionsAttributesByResourceTypeAndExtensionName() is always followed - // by a call to getExtensionAttributes(). The latter returns something meaningful for the client - // and it's used in the identifiable.getExtension() method. The map extensionAttributesMap can't be stored in the cache to be returned - // as we can't ensure synchronization with the resources map (if extensions or identifiables are updated/removed). - // We should refactor this method to return void. - return null; } /** @@ -497,9 +490,9 @@ private void addAllExtensionAttributesToCache(String id, Map> getAllExtensionsAttributesByResourceType(UUID networkUuid, int variantNum, ResourceType type) { + public void loadAllExtensionsAttributesByResourceType(UUID networkUuid, int variantNum, ResourceType type) { if (!fullyLoadedExtensions) { // if collection has not yet been fully loaded we load it from the server Map> extensionAttributesMap = delegate.getAllExtensionsAttributesByResourceType(networkUuid, variantNum, type); @@ -508,13 +501,6 @@ public Map> getAllExtensionsAttributesB extensionAttributesMap.forEach(this::addAllExtensionAttributesToCache); fullyLoadedExtensions = true; } - //TODO This method is only used to load extension attributes in the collection cache when using preloading collection. - // The return is never used by the client as the call to getAllExtensionsAttributesByResourceType() is always followed - // by a call to getAllExtensionsAttributesByIdentifiableId(). The latter returns something meaningful for the client - // and it's used in the identifiable.getExtensions() method. The map extensionAttributesMap can't be stored in the cache to be returned - // as we can't ensure synchronization with the resources map (if extensions or identifiables are updated/removed). - // We should refactor this method to return void. - return null; } public void removeExtensionAttributesByExtensionName(String identifiableId, String extensionName) { diff --git a/network-store-iidm-impl/src/test/java/com/powsybl/network/store/iidm/impl/CollectionCacheTest.java b/network-store-iidm-impl/src/test/java/com/powsybl/network/store/iidm/impl/CollectionCacheTest.java index 2b0734b01..86e6b0d63 100644 --- a/network-store-iidm-impl/src/test/java/com/powsybl/network/store/iidm/impl/CollectionCacheTest.java +++ b/network-store-iidm-impl/src/test/java/com/powsybl/network/store/iidm/impl/CollectionCacheTest.java @@ -343,9 +343,9 @@ public void initExtensionsTest() { assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeCalled()); collectionCache.init(); // it means we trust cache content and no more server loading collectionCache.getExtensionAttributes(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "l1", "activePowerControl"); - collectionCache.getAllExtensionsAttributesByResourceTypeAndExtensionName(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "activePowerControl"); + collectionCache.loadAllExtensionsAttributesByResourceTypeAndExtensionName(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "activePowerControl"); collectionCache.getAllExtensionsAttributesByIdentifiableId(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "l1"); - collectionCache.getAllExtensionsAttributesByResourceType(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD); + collectionCache.loadAllExtensionsAttributesByResourceType(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD); assertFalse(mockNetworkStoreClient.isExtensionAttributeLoaderCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeAndNameCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByIdCalled()); @@ -356,11 +356,11 @@ public void initExtensionsTest() { public void getExtensionAttributesWithResourceNotCachedMustThrow() { PowsyblException exception = assertThrows(PowsyblException.class, () -> collectionCache.getExtensionAttributes(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "l1", "activePowerControl")); assertTrue(exception.getMessage().startsWith("Cannot manipulate extensions for identifiable")); - exception = assertThrows(PowsyblException.class, () -> collectionCache.getAllExtensionsAttributesByResourceTypeAndExtensionName(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "activePowerControl")); + exception = assertThrows(PowsyblException.class, () -> collectionCache.loadAllExtensionsAttributesByResourceTypeAndExtensionName(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "activePowerControl")); assertTrue(exception.getMessage().startsWith("Cannot manipulate extensions for identifiable")); exception = assertThrows(PowsyblException.class, () -> collectionCache.getAllExtensionsAttributesByIdentifiableId(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "l1")); assertTrue(exception.getMessage().startsWith("Cannot manipulate extensions for identifiable")); - exception = assertThrows(PowsyblException.class, () -> collectionCache.getAllExtensionsAttributesByResourceType(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD)); + exception = assertThrows(PowsyblException.class, () -> collectionCache.loadAllExtensionsAttributesByResourceType(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD)); assertTrue(exception.getMessage().startsWith("Cannot manipulate extensions for identifiable")); } @@ -372,6 +372,7 @@ public void getExtensionAttributes() { assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeAndNameCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByIdCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeCalled()); + // Get extension twice and verify that the loader is called only the first time because it's cached assertEquals(apc1, collectionCache.getExtensionAttributes(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "l1", "activePowerControl").orElse(null)); assertTrue(mockNetworkStoreClient.isExtensionAttributeLoaderCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeAndNameCalled()); @@ -498,20 +499,21 @@ public void whenExtensionIsCachedThenRemovedClearExtensionCache() { } @Test - public void getExtensionAttributesLoaderByResourceTypeAndName() { + public void loadExtensionAttributesByResourceTypeAndName() { // Load resources in cache assertEquals(Arrays.asList(l1, l2, l3), collectionCache.getResources(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM)); assertFalse(mockNetworkStoreClient.isExtensionAttributeLoaderCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeAndNameCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByIdCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeCalled()); - assertNull(collectionCache.getAllExtensionsAttributesByResourceTypeAndExtensionName(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "activePowerControl")); + // Load extension by resource type and extension name twice and verify that the loader is called only the first time because it's cached + collectionCache.loadAllExtensionsAttributesByResourceTypeAndExtensionName(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "activePowerControl"); assertFalse(mockNetworkStoreClient.isExtensionAttributeLoaderCalled()); assertTrue(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeAndNameCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByIdCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeCalled()); mockNetworkStoreClient.setExtensionAttributesLoaderByResourceTypeAndNameCalled(false); - assertNull(collectionCache.getAllExtensionsAttributesByResourceTypeAndExtensionName(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "activePowerControl")); + collectionCache.loadAllExtensionsAttributesByResourceTypeAndExtensionName(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "activePowerControl"); assertEquals(apc1, collectionCache.getExtensionAttributes(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "l1", "activePowerControl").orElse(null)); assertEquals(apc2, collectionCache.getExtensionAttributes(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "l2", "activePowerControl").orElse(null)); assertFalse(mockNetworkStoreClient.isExtensionAttributeLoaderCalled()); @@ -528,34 +530,37 @@ public void getExtensionAttributesLoaderById() { assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeAndNameCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByIdCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeCalled()); + // Load extension by identifiable id twice and verify that we can then get the single extension from the same identifiable without new fetch as it's already cached assertEquals(Map.of("activePowerControl", apc1, "operatingStatus", os1), collectionCache.getAllExtensionsAttributesByIdentifiableId(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "l1")); assertFalse(mockNetworkStoreClient.isExtensionAttributeLoaderCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeAndNameCalled()); assertTrue(mockNetworkStoreClient.isExtensionAttributesLoaderByIdCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeCalled()); + mockNetworkStoreClient.setExtensionAttributesLoaderByIdCalled(false); assertEquals(apc1, collectionCache.getExtensionAttributes(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "l1", "activePowerControl").orElse(null)); assertEquals(os1, collectionCache.getExtensionAttributes(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "l1", "operatingStatus").orElse(null)); assertFalse(mockNetworkStoreClient.isExtensionAttributeLoaderCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeAndNameCalled()); - assertTrue(mockNetworkStoreClient.isExtensionAttributesLoaderByIdCalled()); + assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByIdCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeCalled()); } @Test - public void getExtensionAttributesLoaderByResourceType() { + public void loadExtensionAttributesByResourceType() { // Load resources in cache assertEquals(Arrays.asList(l1, l2, l3), collectionCache.getResources(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM)); assertFalse(mockNetworkStoreClient.isExtensionAttributeLoaderCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeAndNameCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByIdCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeCalled()); - assertNull(collectionCache.getAllExtensionsAttributesByResourceType(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD)); + // Load extension by resource type twice and verify that the loader is called only the first time because it's cached + collectionCache.loadAllExtensionsAttributesByResourceType(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD); assertFalse(mockNetworkStoreClient.isExtensionAttributeLoaderCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeAndNameCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByIdCalled()); assertTrue(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeCalled()); mockNetworkStoreClient.setExtensionAttributesLoaderByResourceTypeCalled(false); - assertNull(collectionCache.getAllExtensionsAttributesByResourceType(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD)); + collectionCache.loadAllExtensionsAttributesByResourceType(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD); assertEquals(apc1, collectionCache.getExtensionAttributes(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "l1", "activePowerControl").orElse(null)); assertEquals(os1, collectionCache.getExtensionAttributes(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "l1", "operatingStatus").orElse(null)); assertEquals(apc2, collectionCache.getExtensionAttributes(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "l2", "activePowerControl").orElse(null)); @@ -620,7 +625,7 @@ public void extensionGetExtensionThenUpdateThenGetExtensionPreloadingCollection( assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByIdCalled()); assertFalse(mockNetworkStoreClient.isExtensionAttributesLoaderByResourceTypeCalled()); // Load extension in the resource with getExtension in preloading collection - collectionCache.getAllExtensionsAttributesByResourceTypeAndExtensionName(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, ActivePowerControl.NAME); + collectionCache.loadAllExtensionsAttributesByResourceTypeAndExtensionName(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, ActivePowerControl.NAME); ActivePowerControlAttributes apc1Result = (ActivePowerControlAttributes) collectionCache.getExtensionAttributes(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "l1", "activePowerControl").orElse(null); assertEquals(apc1, apc1Result); assertFalse(mockNetworkStoreClient.isExtensionAttributeLoaderCalled()); @@ -631,7 +636,7 @@ public void extensionGetExtensionThenUpdateThenGetExtensionPreloadingCollection( // Update the extension in gen1 apc1Result.setDroop(8.7); // Load extension again with getExtensions in preloading collection - collectionCache.getAllExtensionsAttributesByResourceType(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD); + collectionCache.loadAllExtensionsAttributesByResourceType(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD); Map extensionsAttributesByIdentifiableIdResult = collectionCache.getAllExtensionsAttributesByIdentifiableId(NETWORK_UUID, Resource.INITIAL_VARIANT_NUM, ResourceType.LOAD, "l1"); apc1Result = (ActivePowerControlAttributes) extensionsAttributesByIdentifiableIdResult.get(ActivePowerControl.NAME); ActivePowerControlAttributes updatedApc1 = ActivePowerControlAttributes.builder()