AbstractSecurityAnalysisExecutionInput.java
/**
* Copyright (c) 2023, RTE (http://www.rte-france.com/)
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
* SPDX-License-Identifier: MPL-2.0
*/
package com.powsybl.security.execution;
import com.google.common.io.ByteSource;
import com.powsybl.action.Action;
import com.powsybl.iidm.network.Network;
import com.powsybl.security.LimitViolationType;
import com.powsybl.security.limitreduction.LimitReduction;
import com.powsybl.security.monitor.StateMonitor;
import com.powsybl.security.strategy.OperatorStrategy;
import java.util.*;
/**
* @author Laurent Issertial {@literal <laurent.issertial at rte-france.com>}
*/
public abstract class AbstractSecurityAnalysisExecutionInput<T extends AbstractSecurityAnalysisExecutionInput<T>> {
private NetworkVariant networkVariant;
private ByteSource contingenciesSource;
private final List<String> resultExtensions = new ArrayList<>();
private final Set<LimitViolationType> violationTypes = EnumSet.noneOf(LimitViolationType.class);
private boolean withLogs = false;
private final List<OperatorStrategy> operatorStrategies = new ArrayList<>();
private final List<Action> actions = new ArrayList<>();
private final List<StateMonitor> monitors = new ArrayList<>();
private final List<LimitReduction> limitReductions = new ArrayList<>();
public Optional<ByteSource> getContingenciesSource() {
return Optional.ofNullable(contingenciesSource);
}
public List<String> getResultExtensions() {
return Collections.unmodifiableList(resultExtensions);
}
public Set<LimitViolationType> getViolationTypes() {
return Collections.unmodifiableSet(violationTypes);
}
public NetworkVariant getNetworkVariant() {
return networkVariant;
}
public List<OperatorStrategy> getOperatorStrategies() {
return Collections.unmodifiableList(operatorStrategies);
}
public List<Action> getActions() {
return Collections.unmodifiableList(actions);
}
public List<StateMonitor> getMonitors() {
return Collections.unmodifiableList(monitors);
}
public List<LimitReduction> getLimitReductions() {
return Collections.unmodifiableList(limitReductions);
}
public boolean isWithLogs() {
return withLogs;
}
public T setContingenciesSource(ByteSource contingenciesSource) {
this.contingenciesSource = contingenciesSource;
return self();
}
public T addResultExtension(String resultExtension) {
resultExtensions.add(Objects.requireNonNull(resultExtension));
return self();
}
public T addResultExtensions(Collection<String> resultExtensions) {
this.resultExtensions.addAll(Objects.requireNonNull(resultExtensions));
return self();
}
public T addViolationType(LimitViolationType violationType) {
violationTypes.add(Objects.requireNonNull(violationType));
return self();
}
public T addViolationTypes(Collection<LimitViolationType> violationTypes) {
this.violationTypes.addAll(Objects.requireNonNull(violationTypes));
return self();
}
public T addOperatorStrategies(List<OperatorStrategy> operatorStrategies) {
this.operatorStrategies.addAll(Objects.requireNonNull(operatorStrategies));
return self();
}
public T addActions(List<Action> actions) {
this.actions.addAll(Objects.requireNonNull(actions));
return self();
}
public T setNetworkVariant(Network network, String variantId) {
networkVariant = new NetworkVariant(network, variantId);
return self();
}
public T setOperatorStrategies(List<OperatorStrategy> operatorStrategies) {
Objects.requireNonNull(operatorStrategies);
this.operatorStrategies.clear();
this.operatorStrategies.addAll(operatorStrategies);
return self();
}
public T setActions(List<Action> actions) {
Objects.requireNonNull(actions);
this.actions.clear();
this.actions.addAll(actions);
return self();
}
public T setMonitors(List<StateMonitor> monitors) {
Objects.requireNonNull(monitors);
this.monitors.clear();
this.monitors.addAll(monitors);
return self();
}
public T setLimitReductions(List<LimitReduction> limitReductions) {
Objects.requireNonNull(limitReductions);
this.limitReductions.clear();
this.limitReductions.addAll(limitReductions);
return self();
}
public T setWithLogs(boolean withLogs) {
this.withLogs = withLogs;
return self();
}
protected abstract T self();
}