if (flowOptional.isPresent()) {
flowCount.incrementAndGet();
if (verbose) {
- LOG.info("Flow found: {}", flowOptional.get());
+ LOG.info("Flow found: {}", flowOptional.orElseThrow());
}
} else {
if (verbose) {
try (ReadTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction()) {
Optional<Nodes> nodesDataNode = readOnlyTransaction.read(LogicalDatastoreType.OPERATIONAL, nodes).get();
if (nodesDataNode.isPresent()) {
- Collection<Node> nodesCollection = nodesDataNode.get().nonnullNode().values();
+ Collection<Node> nodesCollection = nodesDataNode.orElseThrow().nonnullNode().values();
if (!nodesCollection.isEmpty()) {
for (Node node : nodesCollection) {
LOG.info("Switch with ID {} discovered !!", node.getId().getValue());
LOG.debug("The ownership state for node {} is not cached. Retrieving from the EOS Datastore", nodeId);
Optional<EntityOwnershipState> status = getCurrentOwnershipStatus(nodeId);
if (status.isPresent()) {
- state = status.get();
+ state = status.orElseThrow();
ownershipStateCache.put(nodeId, state);
} else {
LOG.warn("Fetching ownership status failed for node {}", nodeId);
org.opendaylight.mdsal.eos.binding.api.Entity entity = createNodeEntity(nodeId);
Optional<EntityOwnershipState> ownershipStatus = eos.getOwnershipState(entity);
if (ownershipStatus.isPresent()) {
- LOG.trace("Fetched ownership status for node {} is {}", nodeId, ownershipStatus.get());
+ LOG.trace("Fetched ownership status for node {} is {}", nodeId, ownershipStatus.orElseThrow());
}
return ownershipStatus;
}
InstanceIdentifier<Group> groupIdent = buildGroupInstanceIdentifier(nodeIdent, groupId);
LOG.info("Reading the group from config inventory: {}", groupId);
try (ReadTransaction readTransaction = forwardingRulesManager.getReadTransaction()) {
- Optional<Group> group = readTransaction.read(LogicalDatastoreType.CONFIGURATION, groupIdent).get();
- if (group.isPresent()) {
- final AddGroupInputBuilder builder = new AddGroupInputBuilder(group.get());
+ Optional<Group> optGroup = readTransaction.read(LogicalDatastoreType.CONFIGURATION, groupIdent)
+ .get();
+ if (optGroup.isPresent()) {
+ final Group group = optGroup.orElseThrow();
+ final AddGroupInputBuilder builder = new AddGroupInputBuilder(group);
builder.setNode(new NodeRef(nodeIdent.firstIdentifierOf(Node.class)));
builder.setGroupRef(new GroupRef(nodeIdent));
builder.setTransactionUri(new Uri(forwardingRulesManager.getNewTransactionId()));
BundleInnerMessage bundleInnerMessage = new BundleAddGroupCaseBuilder()
- .setAddGroupCaseData(new AddGroupCaseDataBuilder(group.get()).build()).build();
+ .setAddGroupCaseData(new AddGroupCaseDataBuilder(group).build()).build();
Message groupMessage = new MessageBuilder()
.setNode(new NodeRef(nodeIdent.firstIdentifierOf(Node.class)))
.setBundleInnerMessage(bundleInnerMessage)
try (ReadTransaction readTransaction = provider.getReadTransaction()) {
Optional<Group> group = readTransaction.read(LogicalDatastoreType.CONFIGURATION, groupIdent).get();
if (group.isPresent()) {
- final AddGroupInputBuilder builder = new AddGroupInputBuilder(group.get());
+ final AddGroupInputBuilder builder = new AddGroupInputBuilder(group.orElseThrow());
builder.setNode(new NodeRef(nodeIdent.firstIdentifierOf(Node.class)));
builder.setGroupRef(new GroupRef(nodeIdent));
builder.setTransactionUri(new Uri(provider.getNewTransactionId()));
public FlowNodeReconciliationImpl(final ForwardingRulesManager manager, final DataBroker db,
final String serviceName, final int priority, final ResultState resultState,
final FlowGroupCacheManager flowGroupCacheManager) {
- this.provider = requireNonNull(manager, "ForwardingRulesManager can not be null!");
+ provider = requireNonNull(manager, "ForwardingRulesManager can not be null!");
dataBroker = requireNonNull(db, "DataBroker can not be null!");
this.serviceName = serviceName;
this.priority = priority;
/* Push flows and groups via bundle add messages */
Optional<FlowCapableNode> finalFlowNode = flowNode;
- ListenableFuture<List<RpcResult<AddBundleMessagesOutput>>> addbundlesFuture
- = Futures.transformAsync(deleteAllFlowGroupsFuture, rpcResult -> {
- if (rpcResult.isSuccessful()) {
- LOG.debug("Adding delete all flow/group message is successful for device {}", dpnId);
- return Futures.allAsList(addBundleMessages(finalFlowNode.get(), bundleIdValue,
- nodeIdentity));
- }
- return Futures.immediateFuture(null);
- }, service);
+ ListenableFuture<List<RpcResult<AddBundleMessagesOutput>>> addbundlesFuture =
+ Futures.transformAsync(deleteAllFlowGroupsFuture, rpcResult -> {
+ if (rpcResult.isSuccessful()) {
+ LOG.debug("Adding delete all flow/group message is successful for device {}", dpnId);
+ return Futures.allAsList(addBundleMessages(finalFlowNode.orElseThrow(), bundleIdValue,
+ nodeIdentity));
+ }
+ return Futures.immediateFuture(null);
+ }, service);
/* Commit the bundle on the openflow switch */
- ListenableFuture<RpcResult<ControlBundleOutput>> commitBundleFuture
- = Futures.transformAsync(addbundlesFuture, rpcResult -> {
- LOG.debug("Adding bundle messages completed for device {}", dpnId);
- return salBundleService.controlBundle(commitBundleInput);
- }, service);
+ ListenableFuture<RpcResult<ControlBundleOutput>> commitBundleFuture =
+ Futures.transformAsync(addbundlesFuture, rpcResult -> {
+ LOG.debug("Adding bundle messages completed for device {}", dpnId);
+ return salBundleService.controlBundle(commitBundleInput);
+ }, service);
/* Bundles not supported for meters */
- Collection<Meter> meters = flowNode.get().nonnullMeter().values();
+ Collection<Meter> meters = finalFlowNode.orElseThrow().nonnullMeter().values();
Futures.transformAsync(commitBundleFuture,
rpcResult -> {
if (rpcResult.isSuccessful()) {
BigInteger dpnId = getDpnIdFromNodeName(node);
OF_EVENT_LOG.debug("Reconciliation Start, Node: {}", dpnId);
- Optional<FlowCapableNode> flowNode;
+ Optional<FlowCapableNode> optFlowNode;
// initialize the counter
int counter = 0;
try (ReadTransaction trans = provider.getReadTransaction()) {
- flowNode = trans.read(LogicalDatastoreType.CONFIGURATION, nodeIdentity).get();
+ optFlowNode = trans.read(LogicalDatastoreType.CONFIGURATION, nodeIdentity).get();
} catch (ExecutionException | InterruptedException e) {
LOG.warn("Fail with read Config/DS for Node {} !", nodeIdentity, e);
return false;
}
- if (flowNode.isPresent()) {
+ if (optFlowNode.isPresent()) {
/* Tables - have to be pushed before groups */
// CHECK if while pushing the update, updateTableInput can be null to emulate a
// table add
- ReconciliationState reconciliationState = new ReconciliationState(
- STARTED, LocalDateTime.now());
+ ReconciliationState reconciliationState = new ReconciliationState(STARTED, LocalDateTime.now());
//put the dpn info into the map
reconciliationStates.put(dpnId.toString(), reconciliationState);
LOG.debug("Triggering reconciliation for node {} with state: {}", dpnId, STARTED);
- Collection<TableFeatures> tableList = flowNode.get().nonnullTableFeatures().values();
+ FlowCapableNode flowNode = optFlowNode.orElseThrow();
+ Collection<TableFeatures> tableList = flowNode.nonnullTableFeatures().values();
for (TableFeatures tableFeaturesItem : tableList) {
TableFeaturesKey tableKey = tableFeaturesItem.key();
KeyedInstanceIdentifier<TableFeatures, TableFeaturesKey> tableFeaturesII = nodeIdentity
}
/* Groups - have to be first */
- Collection<Group> groups = flowNode.get().nonnullGroup().values();
- List<Group> toBeInstalledGroups = new ArrayList<>();
- toBeInstalledGroups.addAll(groups);
+ List<Group> toBeInstalledGroups = new ArrayList<>(flowNode.nonnullGroup().values());
// new list for suspected groups pointing to ports .. when the ports come up
// late
List<Group> suspectedGroups = new ArrayList<>();
if (!toBeInstalledGroups.isEmpty()) {
for (Group group : toBeInstalledGroups) {
LOG.debug(
- "Installing the group {} finally although "
- + "the port is not up after checking for {} times ",
- group.getGroupId(), provider.getReconciliationRetryCount());
+ "Installing the group {} finally although the port is not up after checking for {} times ",
+ group.getGroupId(), provider.getReconciliationRetryCount());
addGroup(groupFutures, group);
}
}
/* Meters */
- Collection<Meter> meters = flowNode.get().nonnullMeter().values();
+ Collection<Meter> meters = flowNode.nonnullMeter().values();
for (Meter meter : meters) {
final KeyedInstanceIdentifier<Meter, MeterKey> meterIdent = nodeIdentity.child(Meter.class,
meter.key());
awaitGroups(node, groupFutures.values());
/* Flows */
- Collection<Table> tables = flowNode.get().getTable() != null ? flowNode.get().nonnullTable().values()
- : Collections.<Table>emptyList();
int flowCount = 0;
- for (Table table : tables) {
+ for (Table table : flowNode.nonnullTable().values()) {
final KeyedInstanceIdentifier<Table, TableKey> tableIdent = nodeIdentity.child(Table.class,
table.key());
Collection<Flow> flows = table.nonnullFlow().values();
List<InstanceIdentifier<StaleGroup>> staleGroupsToBeBulkDeleted = new ArrayList<>();
List<InstanceIdentifier<StaleMeter>> staleMetersToBeBulkDeleted = new ArrayList<>();
- Optional<FlowCapableNode> flowNode = Optional.empty();
+ Optional<FlowCapableNode> optFlowNode = Optional.empty();
try (ReadTransaction trans = provider.getReadTransaction()) {
- flowNode = trans.read(LogicalDatastoreType.CONFIGURATION, nodeIdent).get();
+ optFlowNode = trans.read(LogicalDatastoreType.CONFIGURATION, nodeIdent).get();
} catch (ExecutionException | InterruptedException e) {
LOG.warn("Reconciliation Pre-Processing Fail with read Config/DS for Node {} !", nodeIdent, e);
}
- if (flowNode.isPresent()) {
-
+ if (optFlowNode.isPresent()) {
+ final FlowCapableNode flowNode = optFlowNode.orElseThrow();
LOG.debug("Proceeding with deletion of stale-marked Flows on switch {} using Openflow interface",
nodeIdent);
/* Stale-Flows - Stale-marked Flows have to be removed first for safety */
- Collection<Table> tables = flowNode.get().nonnullTable().values();
+ Collection<Table> tables = flowNode.nonnullTable().values();
for (Table table : tables) {
final KeyedInstanceIdentifier<Table, TableKey> tableIdent = nodeIdent.child(Table.class,
table.key());
final KeyedInstanceIdentifier<Flow, FlowKey> flowIdent = tableIdent.child(Flow.class,
toBeDeletedFlow.key());
- this.provider.getFlowCommiter().remove(flowIdent, toBeDeletedFlow, nodeIdent);
+ provider.getFlowCommiter().remove(flowIdent, toBeDeletedFlow, nodeIdent);
staleFlowsToBeBulkDeleted.add(getStaleFlowInstanceIdentifier(staleFlow, nodeIdent));
}
// before attempting to delete groups - just in case there are references
/* Stale-marked Groups - Can be deleted after flows */
- Collection<StaleGroup> staleGroups = flowNode.get().nonnullStaleGroup().values();
- for (StaleGroup staleGroup : staleGroups) {
-
+ for (StaleGroup staleGroup : flowNode.nonnullStaleGroup().values()) {
GroupBuilder groupBuilder = new GroupBuilder(staleGroup);
Group toBeDeletedGroup = groupBuilder.setGroupId(staleGroup.getGroupId()).build();
final KeyedInstanceIdentifier<Group, GroupKey> groupIdent = nodeIdent.child(Group.class,
toBeDeletedGroup.key());
- this.provider.getGroupCommiter().remove(groupIdent, toBeDeletedGroup, nodeIdent);
+ provider.getGroupCommiter().remove(groupIdent, toBeDeletedGroup, nodeIdent);
staleGroupsToBeBulkDeleted.add(getStaleGroupInstanceIdentifier(staleGroup, nodeIdent));
}
LOG.debug("Proceeding with deletion of stale-marked Meters for switch {} using Openflow interface",
nodeIdent);
/* Stale-marked Meters - can be deleted anytime - so least priority */
- Collection<StaleMeter> staleMeters = flowNode.get().getStaleMeter().values();
-
- for (StaleMeter staleMeter : staleMeters) {
+ for (StaleMeter staleMeter : flowNode.nonnullStaleMeter().values()) {
MeterBuilder meterBuilder = new MeterBuilder(staleMeter);
Meter toBeDeletedMeter = meterBuilder.setMeterId(staleMeter.getMeterId()).build();
final KeyedInstanceIdentifier<Meter, MeterKey> meterIdent = nodeIdent.child(Meter.class,
toBeDeletedMeter.key());
- this.provider.getMeterCommiter().remove(meterIdent, toBeDeletedMeter, nodeIdent);
+ provider.getMeterCommiter().remove(meterIdent, toBeDeletedMeter, nodeIdent);
staleMetersToBeBulkDeleted.add(getStaleMeterInstanceIdentifier(staleMeter, nodeIdent));
}
* Adding cache to data access object of {@link FlowCapableNode}.
*/
public class FlowCapableNodeSnapshotDao implements FlowCapableNodeDao {
-
private final ConcurrentHashMap<String, FlowCapableNode> cache = new ConcurrentHashMap<>();
- public void updateCache(@NonNull NodeId nodeId, Optional<FlowCapableNode> dataAfter) {
+ public void updateCache(final @NonNull NodeId nodeId, final Optional<FlowCapableNode> dataAfter) {
if (dataAfter.isPresent()) {
- cache.put(nodeId.getValue(), dataAfter.get());
+ cache.put(nodeId.getValue(), dataAfter.orElseThrow());
} else {
cache.remove(nodeId.getValue());
}
}
@Override
- public Optional<FlowCapableNode> loadByNodeId(@NonNull NodeId nodeId) {
- final FlowCapableNode node = cache.get(nodeId.getValue());
- return Optional.ofNullable(node);
+ public Optional<FlowCapableNode> loadByNodeId(final NodeId nodeId) {
+ return Optional.ofNullable(cache.get(nodeId.getValue()));
}
}
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frsync.NodeListener;
* Abstract Listener for node changes.
*/
public abstract class AbstractFrmSyncListener<T extends DataObject> implements NodeListener<T> {
-
private static final Logger LOG = LoggerFactory.getLogger(AbstractFrmSyncListener.class);
@Override
- public void onDataTreeChanged(@NonNull final Collection<DataTreeModification<T>> modifications) {
+ public void onDataTreeChanged(final Collection<DataTreeModification<T>> modifications) {
for (DataTreeModification<T> modification : modifications) {
final NodeId nodeId = PathUtil.digNodeId(modification.getRootPath().getRootIdentifier());
if (LOG.isTraceEnabled()) {
LOG.trace("DataTreeModification of {} in {} datastore", nodeId.getValue(), dsType());
}
- try {
- final Optional<ListenableFuture<Boolean>> optFuture = processNodeModification(modification);
- if (optFuture.isPresent()) {
- final ListenableFuture<Boolean> future = optFuture.get();
+ processNodeModification(modification).ifPresent(future -> {
+ try {
future.get(15000, TimeUnit.MILLISECONDS);
if (LOG.isTraceEnabled()) {
LOG.trace("Syncup for {} return from {} listener", nodeId.getValue(), dsType());
}
+ } catch (InterruptedException | ExecutionException | TimeoutException e) {
+ LOG.error("Error processing inventory node modification: {}", nodeId.getValue(), e);
}
- } catch (InterruptedException | ExecutionException | TimeoutException e) {
- LOG.error("Error processing inventory node modification: {}", nodeId.getValue(), e);
- }
+ });
}
}
DataTreeModification<T> modification);
protected abstract LogicalDatastoreType dsType();
-
}
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collection;
import java.util.Optional;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
}
@Override
- public void onDataTreeChanged(@NonNull final Collection<DataTreeModification<FlowCapableNode>> modifications) {
+ public void onDataTreeChanged(final Collection<DataTreeModification<FlowCapableNode>> modifications) {
super.onDataTreeChanged(modifications);
}
configSnapshot.updateCache(nodeId, Optional.ofNullable(modification.getRootNode().getDataAfter()));
final Optional<FlowCapableNode> operationalNode = operationalDao.loadByNodeId(nodeId);
- if (!operationalNode.isPresent()) {
+ if (operationalNode.isEmpty()) {
LOG.debug("Skip syncup, {} operational is not present", nodeId.getValue());
return Optional.empty();
}
final FlowCapableNode dataAfter = configModification.getDataAfter();
final ListenableFuture<Boolean> endResult;
if (dataBefore == null && dataAfter != null) {
- endResult = onNodeAdded(nodePath, dataAfter, operationalNode.get());
+ endResult = onNodeAdded(nodePath, dataAfter, operationalNode.orElseThrow());
} else if (dataBefore != null && dataAfter == null) {
endResult = onNodeDeleted(nodePath, dataBefore);
} else {
import java.util.Date;
import java.util.Map;
import java.util.Optional;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
}
@Override
- public void onDataTreeChanged(@NonNull final Collection<DataTreeModification<Node>> modifications) {
+ public void onDataTreeChanged(final Collection<DataTreeModification<Node>> modifications) {
super.onDataTreeChanged(modifications);
}
.child(Node.class, new NodeKey(ModificationUtil.nodeId(modification)))
.augmentation(FlowCapableNode.class);
final FlowCapableNode fcOperationalNode = ModificationUtil.flowCapableNodeAfter(modification);
- final SyncupEntry syncupEntry = new SyncupEntry(nodeConfiguration.get(), LogicalDatastoreType.CONFIGURATION,
- fcOperationalNode, dsType());
+ final SyncupEntry syncupEntry = new SyncupEntry(nodeConfiguration.orElseThrow(),
+ LogicalDatastoreType.CONFIGURATION, fcOperationalNode, dsType());
return Optional.of(reactor.syncup(nodePath, syncupEntry));
} else {
LOG.debug("Config not present for reconciliation: {}", nodeId.getValue());
if (isSuccess) {
if (count.isPresent()) {
- long successCount = count.get().getSuccessCount().toJava();
+ long successCount = count.orElseThrow().getSuccessCount().toJava();
counterBuilder.setSuccessCount(Uint32.valueOf(++successCount));
LOG.debug("Reconcile success count {} for the node: {} ", successCount, nodeId);
} else {
counterBuilder.setSuccessCount(Uint32.ONE);
}
+ } else if (count.isPresent()) {
+ long failureCount = count.orElseThrow().getFailureCount().toJava();
+ counterBuilder.setFailureCount(Uint32.valueOf(++failureCount));
+ LOG.debug("Reconcile failure count {} for the node: {} ", failureCount, nodeId);
} else {
- if (count.isPresent()) {
- long failureCount = count.get().getFailureCount().toJava();
- counterBuilder.setFailureCount(Uint32.valueOf(++failureCount));
- LOG.debug("Reconcile failure count {} for the node: {} ", failureCount, nodeId);
- } else {
- counterBuilder.setFailureCount(Uint32.ONE);
- }
+ counterBuilder.setFailureCount(Uint32.ONE);
}
try {
tx.mergeParentStructureMerge(LogicalDatastoreType.OPERATIONAL, instanceIdentifier,
return reconciliationState;
}
- private void printReconciliationStates(List<String> result) {
+ private void printReconciliationStates(final List<String> result) {
session.getConsole().println(getHeaderOutput());
session.getConsole().println(getLineSeparator());
result.stream().forEach(p -> session.getConsole().println(p));
}
@SuppressWarnings("IllegalCatch")
- private Map<String, String> getRemoteReconciliationStates(String ipAddress) {
+ private Map<String, String> getRemoteReconciliationStates(final String ipAddress) {
Map<String, String> jmxReconciliationStates = new HashMap<>();
try {
String getReconcilationRemoteResponse = invokeRemoteRestOperation(ipAddress);
return reconciliationJMXServiceMBean.acquireReconciliationStates();
}
- private String invokeRemoteRestOperation(String ipAddress) throws Exception {
+ private String invokeRemoteRestOperation(final String ipAddress) throws Exception {
String restUrl = buildRemoteReconcilationUrl(ipAddress);
LOG.info("invokeRemoteReconcilationState() REST URL: {}", restUrl);
String authString = JMX_REST_HTTP_AUTH_UNAME_PWD;
LOG.debug("sending http request for accessing remote reconcilation");
HttpResponse<String> response = HttpClient.newBuilder()
- .connectTimeout(request.timeout().get().plusMillis(1000))
+ .connectTimeout(request.timeout().orElseThrow().plusMillis(1000))
.build()
.send(request, HttpResponse.BodyHandlers.ofString());
// Response code for success should be 200
}
- String buildRemoteReconcilationUrl(String host) {
+ String buildRemoteReconcilationUrl(final String host) {
String targetHostAsString;
InetAddress hostInetAddress = InetAddresses.forString(host);
if (hostInetAddress instanceof Inet6Address) {
private static final Logger LOG = LoggerFactory.getLogger(Reconciliation.class);
private ReconciliationService reconciliationService;
- public void setReconciliationService(ReconciliationService reconciliationService) {
+ public void setReconciliationService(final ReconciliationService reconciliationService) {
this.reconciliationService = reconciliationService;
}
System.out.println("Reconciliation triggered for the node(s)");
printInProgressNodes(rpcResult.getResult());
} else {
- System.out.println(rpcResult.getErrors().stream().findFirst().get().getMessage());
+ System.out.println(rpcResult.getErrors().stream().findFirst().orElseThrow().getMessage());
}
} catch (ExecutionException e) {
LOG.error("Error occurred while invoking reconcile RPC for node {}", nodes, e);
}
@SuppressWarnings("checkstyle:RegexpSinglelineJava")
- private static void printInProgressNodes(ReconcileOutput reconcileOutput) {
+ private static void printInProgressNodes(final ReconcileOutput reconcileOutput) {
Set<Uint64> inprogressNodes = reconcileOutput.getInprogressNodes();
if (inprogressNodes.size() > 0) {
StringBuilder stringBuilder = new StringBuilder();
try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
Optional<Node> result = tx.read(LogicalDatastoreType.OPERATIONAL, path).get();
if (result.isPresent()) {
- Node node = result.get();
+ Node node = result.orElseThrow();
String name;
Collection<NodeConnector> nodeConnectors = node.nonnullNodeConnector().values();
List<String> portList = new ArrayList<>();
public static Collection<ReconcileCounter> getReconcileCount(final DataBroker dataBroker) {
InstanceIdentifier<ReconciliationCounter> instanceIdentifier = InstanceIdentifier
.builder(ReconciliationCounter.class).build();
- Collection<ReconcileCounter> output = Collections.emptyList();
try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
- Optional<ReconciliationCounter> result =
- tx.read(LogicalDatastoreType.OPERATIONAL, instanceIdentifier).get();
- if (result.isPresent()) {
- output = result.get().nonnullReconcileCounter().values();
- }
+ final var result = tx.read(LogicalDatastoreType.OPERATIONAL, instanceIdentifier).get();
+ return result.map(counter -> counter.nonnullReconcileCounter().values()).orElse(List.of());
} catch (ExecutionException | InterruptedException e) {
LOG.error("Error reading reconciliation counter from datastore", e);
+ return List.of();
}
- return output;
}
}
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
-import java.util.Optional;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.eos.common.api.EntityOwnershipState;
public static boolean isEntityOwned(final EntityOwnershipService eos, final String nodeId) {
requireNonNull(eos, "Entity ownership service must not be null");
-
- EntityOwnershipState state = null;
- Optional<EntityOwnershipState> status = getCurrentOwnershipStatus(eos, nodeId);
- if (status.isPresent()) {
- state = status.get();
- } else {
- LOG.error("Fetching ownership status failed for node {}", nodeId);
- }
- return state != null && state.equals(EntityOwnershipState.IS_OWNER);
+ return EntityOwnershipState.IS_OWNER == currentOwnershipStatus(eos, nodeId);
}
public static org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819
return secAuthenticatorOk;
}
- private static Optional<EntityOwnershipState> getCurrentOwnershipStatus(final EntityOwnershipService eos,
+ private static @Nullable EntityOwnershipState currentOwnershipStatus(final EntityOwnershipService eos,
final String nodeId) {
- Entity entity = createNodeEntity(nodeId);
- Optional<EntityOwnershipState> ownershipStatus = eos.getOwnershipState(entity);
-
- if (ownershipStatus.isPresent()) {
- LOG.debug("Fetched ownership status for node {} is {}", nodeId, ownershipStatus.get());
+ var optStatus = eos.getOwnershipState(new Entity(SERVICE_ENTITY_TYPE, nodeId));
+ if (optStatus.isEmpty()) {
+ LOG.error("Fetching ownership status failed for node {}", nodeId);
+ return null;
}
- return ownershipStatus;
- }
- private static Entity createNodeEntity(final String nodeId) {
- return new Entity(SERVICE_ENTITY_TYPE, nodeId);
+ final var status = optStatus.orElseThrow();
+ LOG.debug("Fetched ownership status for node {} is {}", nodeId, status);
+ return status;
}
private static NodeConnectorRef getNodeConnectorRefFromLink(final TpId tpId, final org.opendaylight.yang.gen.v1.urn
.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId nodeId) {
String nodeConnectorId = tpId.getValue();
- InstanceIdentifier<NodeConnector> nciid
- = InstanceIdentifier.builder(Nodes.class)
- .child(
- Node.class,
- new NodeKey(new org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819
- .NodeId(nodeId)))
- .child(
- NodeConnector.class,
- new NodeConnectorKey(new NodeConnectorId(nodeConnectorId)))
- .build();
- return new NodeConnectorRef(nciid);
+ return new NodeConnectorRef(InstanceIdentifier.builder(Nodes.class)
+ .child(Node.class,
+ new NodeKey(new org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId(nodeId)))
+ .child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId(nodeConnectorId)))
+ .build());
}
}
import org.slf4j.LoggerFactory;
final class TopologyManagerUtil {
-
private static final Logger LOG = LoggerFactory.getLogger(TopologyManagerUtil.class);
private TopologyManagerUtil() {
+ // Hidden on purpose
}
static void removeAffectedLinks(final NodeId id, final TransactionChainManager manager,
- InstanceIdentifier<Topology> topology) {
- Optional<Topology> topologyOptional = Optional.empty();
+ final InstanceIdentifier<Topology> topology) {
+ final Optional<Topology> topologyOptional;
try {
topologyOptional = manager.readFromTransaction(LogicalDatastoreType.OPERATIONAL, topology).get();
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Error reading topology data for topology {}: {}", topology, e.getMessage());
LOG.debug("Error reading topology data for topology.. ", e);
- }
- if (topologyOptional.isPresent()) {
- removeAffectedLinks(id, topologyOptional, manager, topology);
- }
- }
-
- private static void removeAffectedLinks(final NodeId id, Optional<Topology> topologyOptional,
- TransactionChainManager manager,
- final InstanceIdentifier<Topology> topology) {
- if (!topologyOptional.isPresent()) {
return;
}
-
- for (Link link : topologyOptional.get().nonnullLink().values()) {
- if (id.equals(link.getSource().getSourceNode()) || id.equals(link.getDestination().getDestNode())) {
- manager.addDeleteOperationToTxChain(LogicalDatastoreType.OPERATIONAL, linkPath(link, topology));
+ if (topologyOptional.isPresent()) {
+ for (Link link : topologyOptional.orElseThrow().nonnullLink().values()) {
+ if (id.equals(link.getSource().getSourceNode()) || id.equals(link.getDestination().getDestNode())) {
+ manager.addDeleteOperationToTxChain(LogicalDatastoreType.OPERATIONAL, linkPath(link, topology));
+ }
}
}
}
static void removeAffectedLinks(final TpId id, final TransactionChainManager manager,
final InstanceIdentifier<Topology> topology) {
- Optional<Topology> topologyOptional = Optional.empty();
+ final Optional<Topology> topologyOptional;
try {
topologyOptional = manager.readFromTransaction(LogicalDatastoreType.OPERATIONAL, topology).get();
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Error reading topology data for topology {}: {}", topology, e.getMessage());
LOG.debug("Error reading topology data for topology..", e);
- }
- if (topologyOptional.isPresent()) {
- removeAffectedLinks(id, topologyOptional, manager, topology);
- }
- }
-
- private static void removeAffectedLinks(final TpId id, Optional<Topology> topologyOptional,
- TransactionChainManager manager,
- final InstanceIdentifier<Topology> topology) {
- if (!topologyOptional.isPresent()) {
return;
}
-
- for (Link link : topologyOptional.get().nonnullLink().values()) {
- if (id.equals(link.getSource().getSourceTp()) || id.equals(link.getDestination().getDestTp())) {
- manager.addDeleteOperationToTxChain(LogicalDatastoreType.OPERATIONAL, linkPath(link, topology));
+ if (topologyOptional.isPresent()) {
+ for (Link link : topologyOptional.orElseThrow().nonnullLink().values()) {
+ if (id.equals(link.getSource().getSourceTp()) || id.equals(link.getDestination().getDestTp())) {
+ manager.addDeleteOperationToTxChain(LogicalDatastoreType.OPERATIONAL, linkPath(link, topology));
+ }
}
}
}
static InstanceIdentifier<Link> linkPath(final Link link, final InstanceIdentifier<Topology> topology) {
return topology.child(Link.class, link.key());
}
-
-
}
*/
package org.opendaylight.openflowplugin.extension.api;
-import java.util.Collections;
-import org.junit.Assert;
+import static org.junit.Assert.assertEquals;
+
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.GeneralAugMatchNotifPacketIn;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.GeneralAugMatchNotifPacketInBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.GeneralExtensionListGrouping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.list.grouping.ExtensionList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.list.grouping.ExtensionListBuilder;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
/**
* Test of {@link GroupingLooseResolver}.
eqGroup.add(GeneralAugMatchNodesNodeTableFlow.class);
eqGroup.add(GeneralAugMatchNotifPacketIn.class);
- ExtensionList extension1 = new ExtensionListBuilder().setExtensionKey(JoachimTheBig.VALUE).build();
Match match1 = new MatchBuilder()
- .addAugmentation(new GeneralAugMatchNodesNodeTableFlowBuilder()
- .setExtensionList(Collections.singletonMap(extension1.key(), extension1))
- .build())
- .build();
+ .addAugmentation(new GeneralAugMatchNodesNodeTableFlowBuilder()
+ .setExtensionList(BindingMap.of(new ExtensionListBuilder()
+ .setExtensionKey(JoachimTheBig.VALUE)
+ .build()))
+ .build())
+ .build();
- org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.packet.received.MatchBuilder mb2 =
- new org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service
- .rev130709.packet.received.MatchBuilder();
- ExtensionList extension2 = new ExtensionListBuilder().setExtensionKey(JoachimTheTiny.VALUE).build();
- org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.packet.received.Match match2 =
- mb2.addAugmentation(new GeneralAugMatchNotifPacketInBuilder()
- .setExtensionList(Collections.singletonMap(extension2.key(), extension2)).build()).build();
+ var match2 = new org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service .rev130709.packet.received
+ .MatchBuilder().addAugmentation(new GeneralAugMatchNotifPacketInBuilder()
+ .setExtensionList(BindingMap.of(
+ new ExtensionListBuilder().setExtensionKey(JoachimTheTiny.VALUE).build()))
+ .build())
+ .build();
- Assert.assertEquals(JoachimTheBig.VALUE,
- eqGroup.getExtension(match1).get().nonnullExtensionList().values().iterator().next().getExtensionKey());
- Assert.assertEquals(JoachimTheTiny.VALUE,
- eqGroup.getExtension(match2).get().nonnullExtensionList().values().iterator().next().getExtensionKey());
+ assertEquals(JoachimTheBig.VALUE, eqGroup.getExtension(match1).orElseThrow()
+ .nonnullExtensionList().values().iterator().next().getExtensionKey());
+ assertEquals(JoachimTheTiny.VALUE, eqGroup.getExtension(match2).orElseThrow()
+ .nonnullExtensionList().values().iterator().next().getExtensionKey());
}
private interface JoachimTheBig extends ExtensionKey {
*/
package org.opendaylight.openflowplugin.extension.api;
-import java.util.Collections;
-import org.junit.Assert;
+import static org.junit.Assert.assertEquals;
+
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.list.grouping.ExtensionList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.list.grouping.ExtensionListBuilder;
import org.opendaylight.yangtools.yang.binding.Augmentable;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
/**
* Test of {@link GroupingResolver}.
ExtensionList extension1 = new ExtensionListBuilder().setExtensionKey(JoachimTheBig.VALUE).build();
Match match1 = new MatchBuilder()
- .addAugmentation(new GeneralAugMatchNodesNodeTableFlowBuilder()
- .setExtensionList(Collections.singletonMap(extension1.key(), extension1))
- .build())
- .build();
+ .addAugmentation(new GeneralAugMatchNodesNodeTableFlowBuilder()
+ .setExtensionList(BindingMap.of(extension1))
+ .build())
+ .build();
ExtensionList extension2 = new ExtensionListBuilder().setExtensionKey(JoachimTheTiny.VALUE).build();
Match match2 = new MatchBuilder()
- .addAugmentation(new GeneralAugMatchNodesNodeTableFlowBuilder()
- .setExtensionList(Collections.singletonMap(extension2.key(), extension2))
- .build())
- .build();
+ .addAugmentation(new GeneralAugMatchNodesNodeTableFlowBuilder()
+ .setExtensionList(BindingMap.of(extension2))
+ .build())
+ .build();
- Assert.assertEquals(JoachimTheBig.VALUE,
- eqGroup.getExtension(match1).get().nonnullExtensionList().values().iterator().next().getExtensionKey());
- Assert.assertEquals(JoachimTheTiny.VALUE,
- eqGroup.getExtension(match2).get().nonnullExtensionList().values().iterator().next().getExtensionKey());
+ assertEquals(JoachimTheBig.VALUE, eqGroup.getExtension(match1).orElseThrow()
+ .nonnullExtensionList().values().iterator().next().getExtensionKey());
+ assertEquals(JoachimTheTiny.VALUE, eqGroup.getExtension(match2).orElseThrow()
+ .nonnullExtensionList().values().iterator().next().getExtensionKey());
}
private interface JoachimTheBig extends ExtensionKey {
*/
package org.opendaylight.openflowplugin.extension.api;
-import java.util.Collections;
-import org.junit.Assert;
+import static org.junit.Assert.assertEquals;
+
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.field._case.SetField;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.field._case.SetFieldBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.GeneralAugMatchRpcAddFlowWriteActionsSetField;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.GeneralAugMatchRpcAddFlowWriteActionsSetFieldBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.GeneralExtensionListGrouping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.list.grouping.ExtensionList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.list.grouping.ExtensionListBuilder;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
public class SetFieldExtensionTest {
@Test
eqGroup.add(GeneralAugMatchRpcAddFlowWriteActionsSetField.class);
eqGroup.add(GeneralAugMatchNodesNodeTableFlowWriteActionsSetField.class);
- ExtensionList extension1 = new ExtensionListBuilder().setExtensionKey(ZVendorExt1.VALUE).build();
SetField setField1 = new SetFieldBuilder()
- .addAugmentation(new GeneralAugMatchRpcAddFlowWriteActionsSetFieldBuilder()
- .setExtensionList(Collections.singletonMap(extension1.key(), extension1))
- .build())
- .build();
+ .addAugmentation(new GeneralAugMatchRpcAddFlowWriteActionsSetFieldBuilder()
+ .setExtensionList(BindingMap.of(new ExtensionListBuilder().setExtensionKey(ZVendorExt1.VALUE).build()))
+ .build())
+ .build();
- ExtensionList extension2 = new ExtensionListBuilder().setExtensionKey(ZVendorExt2.VALUE).build();
SetField setField2 = new SetFieldBuilder()
- .addAugmentation(new GeneralAugMatchNodesNodeTableFlowWriteActionsSetFieldBuilder()
- .setExtensionList(Collections.singletonMap(extension2.key(), extension2))
- .build())
- .build();
-
- Assert.assertEquals(ZVendorExt1.VALUE,
- eqGroup.getExtension(setField1).get().nonnullExtensionList().values().iterator().next()
- .getExtensionKey());
- Assert.assertEquals(ZVendorExt2.VALUE,
- eqGroup.getExtension(setField2).get().nonnullExtensionList().values().iterator().next()
- .getExtensionKey());
+ .addAugmentation(new GeneralAugMatchNodesNodeTableFlowWriteActionsSetFieldBuilder()
+ .setExtensionList(BindingMap.of(new ExtensionListBuilder().setExtensionKey(ZVendorExt2.VALUE).build()))
+ .build())
+ .build();
+
+ assertEquals(ZVendorExt1.VALUE, eqGroup.getExtension(setField1).orElseThrow()
+ .nonnullExtensionList().values().iterator().next().getExtensionKey());
+ assertEquals(ZVendorExt2.VALUE, eqGroup.getExtension(setField2).orElseThrow()
+ .nonnullExtensionList().values().iterator().next() .getExtensionKey());
}
private interface ZVendorExt1 extends ExtensionKey {
public MatchEntry convert(final Extension extension) {
Optional<EricOfIcmpv6NdOptionsTypeGrouping> matchGrouping = MatchUtil.ICMPV6_ND_OPTIONS_TYPE_RESOLVER
.getExtension(extension);
- if (!matchGrouping.isPresent()) {
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- Uint8 value = matchGrouping.get().getEricOfIcmpv6NdOptionsType().getIcmpv6NdOptionsType();
+ Uint8 value = matchGrouping.orElseThrow().getEricOfIcmpv6NdOptionsType().getIcmpv6NdOptionsType();
Icmpv6NdOptionsTypeCaseValueBuilder icmpv6NdOptionsTypeCaseValueBuilder
= new Icmpv6NdOptionsTypeCaseValueBuilder();
icmpv6NdOptionsTypeCaseValueBuilder.setIcmpv6NdOptionsTypeValues(new Icmpv6NdOptionsTypeValuesBuilder()
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(
final EricOfIcmpv6NdOptionsType value, final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(EricAugMatchNodesNodeTableFlow.class,
- new EricAugMatchNodesNodeTableFlowBuilder().setEricOfIcmpv6NdOptionsType(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(EricAugMatchRpcGetFlowStats.class,
- new EricAugMatchRpcGetFlowStatsBuilder().setEricOfIcmpv6NdOptionsType(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(EricAugMatchNotifPacketIn.class, new EricAugMatchNotifPacketInBuilder()
- .setEricOfIcmpv6NdOptionsType(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(EricAugMatchNotifSwitchFlowRemoved.class,
- new EricAugMatchNotifSwitchFlowRemovedBuilder().setEricOfIcmpv6NdOptionsType(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(EricAugMatchPacketInMessage.class,
- new EricAugMatchPacketInMessageBuilder().setEricOfIcmpv6NdOptionsType(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(EricAugMatchNodesNodeTableFlow.class,
+ new EricAugMatchNodesNodeTableFlowBuilder().setEricOfIcmpv6NdOptionsType(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(EricAugMatchRpcGetFlowStats.class,
+ new EricAugMatchRpcGetFlowStatsBuilder().setEricOfIcmpv6NdOptionsType(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(EricAugMatchNotifPacketIn.class,
+ new EricAugMatchNotifPacketInBuilder().setEricOfIcmpv6NdOptionsType(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(EricAugMatchNotifSwitchFlowRemoved.class,
+ new EricAugMatchNotifSwitchFlowRemovedBuilder().setEricOfIcmpv6NdOptionsType(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(EricAugMatchPacketInMessage.class,
+ new EricAugMatchPacketInMessageBuilder().setEricOfIcmpv6NdOptionsType(value).build(), key);
+ };
}
}
\ No newline at end of file
public MatchEntry convert(final Extension extension) {
Optional<EricOfIcmpv6NdReservedGrouping> matchGrouping
= MatchUtil.ICMPV6_ND_RESERVED_RESOLVER.getExtension(extension);
- if (!matchGrouping.isPresent()) {
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- Uint32 value = matchGrouping.get().getEricOfIcmpv6NdReserved().getIcmpv6NdReserved();
+ Uint32 value = matchGrouping.orElseThrow().getEricOfIcmpv6NdReserved().getIcmpv6NdReserved();
Icmpv6NdReservedCaseValueBuilder icmpv6NdReservedCaseValueBuilder = new Icmpv6NdReservedCaseValueBuilder();
icmpv6NdReservedCaseValueBuilder.setIcmpv6NdReservedValues(new Icmpv6NdReservedValuesBuilder()
.setIcmpv6NdReserved(value).build());
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(
final EricOfIcmpv6NdReserved value, final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(EricAugMatchNodesNodeTableFlow.class,
- new EricAugMatchNodesNodeTableFlowBuilder().setEricOfIcmpv6NdReserved(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(EricAugMatchRpcGetFlowStats.class,
- new EricAugMatchRpcGetFlowStatsBuilder().setEricOfIcmpv6NdReserved(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(EricAugMatchNotifPacketIn.class, new EricAugMatchNotifPacketInBuilder()
- .setEricOfIcmpv6NdReserved(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(EricAugMatchNotifSwitchFlowRemoved.class,
- new EricAugMatchNotifSwitchFlowRemovedBuilder().setEricOfIcmpv6NdReserved(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(EricAugMatchPacketInMessage.class,
- new EricAugMatchPacketInMessageBuilder().setEricOfIcmpv6NdReserved(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(EricAugMatchNodesNodeTableFlow.class,
+ new EricAugMatchNodesNodeTableFlowBuilder().setEricOfIcmpv6NdReserved(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(EricAugMatchRpcGetFlowStats.class,
+ new EricAugMatchRpcGetFlowStatsBuilder().setEricOfIcmpv6NdReserved(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(EricAugMatchNotifPacketIn.class,
+ new EricAugMatchNotifPacketInBuilder().setEricOfIcmpv6NdReserved(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(EricAugMatchNotifSwitchFlowRemoved.class,
+ new EricAugMatchNotifSwitchFlowRemovedBuilder().setEricOfIcmpv6NdReserved(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(EricAugMatchPacketInMessage.class,
+ new EricAugMatchPacketInMessageBuilder().setEricOfIcmpv6NdReserved(value).build(), key);
+ };
}
}
\ No newline at end of file
.setExtensionList(BindingMap.of(extListBld.build())).build())
.build();
- assertEquals(Icmpv6NdOptionsTypeKey.VALUE, eqGroup.getExtension(setField).get().nonnullExtensionList()
- .values().iterator().next().getExtensionKey());
+ assertEquals(Icmpv6NdOptionsTypeKey.VALUE, eqGroup.getExtension(setField).orElseThrow()
+ .nonnullExtensionList().values().iterator().next().getExtensionKey());
}
}
.build())
.build();
- assertEquals(Icmpv6NdReservedKey.VALUE, eqGroup.getExtension(setField).get().nonnullExtensionList()
- .values().iterator().next().getExtensionKey());
+ assertEquals(Icmpv6NdReservedKey.VALUE, eqGroup.getExtension(setField).orElseThrow()
+ .nonnullExtensionList().values().iterator().next().getExtensionKey());
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfArpOpGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfArpOpKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.arp.op.grouping.NxmOfArpOp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.arp.op.grouping.NxmOfArpOpBuilder;
import org.opendaylight.yangtools.yang.binding.Augmentation;
-import org.opendaylight.yangtools.yang.common.Uint16;
/**
* Convert to/from SAL flow model to openflowjava model for ArpOpCase.
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmOfArpOpGrouping> matchGrouping = MatchUtil.ARP_OP_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.ARP_OP_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- Uint16 value = matchGrouping.get().getNxmOfArpOp().getValue();
- ArpOpCaseValueBuilder arpOpCaseValueBuilder = new ArpOpCaseValueBuilder();
- arpOpCaseValueBuilder.setArpOpValues(new ArpOpValuesBuilder()
- .setValue(value).build());
return MatchUtil.createDefaultMatchEntryBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx
- .match.rev140421.NxmOfArpOp.VALUE, Nxm0Class.VALUE, arpOpCaseValueBuilder.build()).build();
+ .match.rev140421.NxmOfArpOp.VALUE, Nxm0Class.VALUE, new ArpOpCaseValueBuilder()
+ .setArpOpValues(new ArpOpValuesBuilder()
+ .setValue(matchGrouping.orElseThrow().getNxmOfArpOp().getValue()).build())
+ .build())
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmOfArpOp value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfArpOp(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfArpOp(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmOfArpOp(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfArpOp(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmOfArpOp(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfArpOp(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfArpOp(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmOfArpOp(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfArpOp(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmOfArpOp(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.api.path.MatchPath;
import org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.CodecPreconditionException;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Nxm1Class;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.ArpShaCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxArpShaGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxArpShaKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.arp.sha.grouping.NxmNxArpSha;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.arp.sha.grouping.NxmNxArpShaBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxArpShaGrouping> matchGrouping = MatchUtil.ARP_SHA_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.ARP_SHA_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- MacAddress macAddress = matchGrouping.get().getNxmNxArpSha().getMacAddress();
- ArpShaCaseValueBuilder arpShaCaseValueBuilder = new ArpShaCaseValueBuilder();
- arpShaCaseValueBuilder.setArpShaValues(new ArpShaValuesBuilder()
- .setMacAddress(macAddress).build());
- return MatchUtil.createDefaultMatchEntryBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx
- .match.rev140421.NxmNxArpSha.VALUE, Nxm1Class.VALUE, arpShaCaseValueBuilder.build()).build();
+ return MatchUtil.createDefaultMatchEntryBuilder(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxArpSha.VALUE,
+ Nxm1Class.VALUE,
+ new ArpShaCaseValueBuilder()
+ .setArpShaValues(new ArpShaValuesBuilder()
+ .setMacAddress(matchGrouping.orElseThrow().getNxmNxArpSha().getMacAddress())
+ .build())
+ .build())
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmNxArpSha value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxArpSha(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxArpSha(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxArpSha(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxArpSha(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxArpSha(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxArpSha(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxArpSha(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxArpSha(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxArpSha(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxArpSha(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfArpSpaGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfArpSpaKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.arp.spa.grouping.NxmOfArpSpa;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.arp.spa.grouping.NxmOfArpSpaBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmOfArpSpaGrouping> matchGrouping = MatchUtil.ARP_SPA_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.ARP_SPA_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
return MatchUtil.createDefaultMatchEntryBuilder(
org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmOfArpSpa.VALUE,
Nxm0Class.VALUE, new ArpSpaCaseValueBuilder()
.setArpSpaValues(new ArpSpaValuesBuilder()
- .setValue(Uint32.valueOf(IpConverter.ipv4AddressToLong(matchGrouping.get().getNxmOfArpSpa()
- .getIpv4Address())))
+ .setValue(Uint32.valueOf(
+ IpConverter.ipv4AddressToLong(matchGrouping.orElseThrow().getNxmOfArpSpa().getIpv4Address())))
.build())
.build())
.build();
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmOfArpSpa value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfArpSpa(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfArpSpa(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmOfArpSpa(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfArpSpa(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmOfArpSpa(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfArpSpa(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfArpSpa(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmOfArpSpa(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfArpSpa(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmOfArpSpa(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.api.path.MatchPath;
import org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.CodecPreconditionException;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Nxm1Class;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.ArpThaCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxArpThaGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxArpThaKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.arp.tha.grouping.NxmNxArpTha;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.arp.tha.grouping.NxmNxArpThaBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxArpThaGrouping> matchGrouping = MatchUtil.ARP_THA_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.ARP_THA_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- MacAddress macAddress = matchGrouping.get().getNxmNxArpTha().getMacAddress();
- ArpThaCaseValueBuilder arpThaCaseValueBuilder = new ArpThaCaseValueBuilder();
- arpThaCaseValueBuilder.setArpThaValues(new ArpThaValuesBuilder()
- .setMacAddress(macAddress).build());
- return MatchUtil.createDefaultMatchEntryBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx
- .match.rev140421.NxmNxArpTha.VALUE, Nxm1Class.VALUE, arpThaCaseValueBuilder.build()).build();
-
+ return MatchUtil.createDefaultMatchEntryBuilder(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxArpTha.VALUE,
+ Nxm1Class.VALUE,
+ new ArpThaCaseValueBuilder()
+ .setArpThaValues(new ArpThaValuesBuilder()
+ .setMacAddress(matchGrouping.orElseThrow().getNxmNxArpTha().getMacAddress())
+ .build())
+ .build())
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmNxArpTha value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxArpTha(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxArpTha(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxArpTha(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxArpTha(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxArpTha(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxArpTha(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxArpTha(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxArpTha(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxArpTha(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxArpTha(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfArpTpaGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfArpTpaKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.arp.tpa.grouping.NxmOfArpTpa;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.arp.tpa.grouping.NxmOfArpTpaBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmOfArpTpaGrouping> matchGrouping = MatchUtil.ARP_TPA_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.ARP_TPA_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
return MatchUtil.createDefaultMatchEntryBuilder(
org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmOfArpTpa.VALUE,
Nxm0Class.VALUE, new ArpTpaCaseValueBuilder()
.setArpTpaValues(new ArpTpaValuesBuilder()
- .setValue(Uint32.valueOf(
- IpConverter.ipv4AddressToLong(matchGrouping.get().getNxmOfArpTpa().getIpv4Address()))).build())
+ .setValue(Uint32.valueOf(IpConverter.ipv4AddressToLong(
+ matchGrouping.orElseThrow().getNxmOfArpTpa().getIpv4Address())))
+ .build())
.build())
.build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmOfArpTpa value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfArpTpa(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfArpTpa(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmOfArpTpa(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfArpTpa(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmOfArpTpa(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfArpTpa(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfArpTpa(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmOfArpTpa(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfArpTpa(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmOfArpTpa(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.CodecPreconditionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Nxm1Class;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.CtMarkCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.CtMarkCaseValueBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.nxm.nx.match.ct.mark.grouping.CtMarkValuesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxCtMarkGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxCtMarkKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.ct.mark.grouping.NxmNxCtMark;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.ct.mark.grouping.NxmNxCtMarkBuilder;
*/
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxCtMarkGrouping> matchGrouping = MatchUtil.CT_MARK_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.CT_MARK_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- CtMarkCaseValueBuilder ctMarkCaseValueBuilder = new CtMarkCaseValueBuilder();
- CtMarkValuesBuilder ctMarkValuesBuilder = new CtMarkValuesBuilder();
- ctMarkValuesBuilder.setCtMark(matchGrouping.get().getNxmNxCtMark().getCtMark());
- ctMarkValuesBuilder.setMask(matchGrouping.get().getNxmNxCtMark().getMask());
- ctMarkCaseValueBuilder.setCtMarkValues(ctMarkValuesBuilder.build());
- MatchEntryBuilder ofMatch = MatchUtil
- .createDefaultMatchEntryBuilder(org.opendaylight.yang.gen.v1.urn
- .opendaylight.openflowjava.nx.match.rev140421.NxmNxCtMark.VALUE,
- Nxm1Class.VALUE, ctMarkCaseValueBuilder.build());
- ofMatch.setHasMask(true);
- return ofMatch.build();
+ final var ctMark = matchGrouping.orElseThrow().getNxmNxCtMark();
+ return MatchUtil.createDefaultMatchEntryBuilder(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxCtMark.VALUE,
+ Nxm1Class.VALUE,
+ new CtMarkCaseValueBuilder()
+ .setCtMarkValues(new CtMarkValuesBuilder()
+ .setCtMark(ctMark.getCtMark())
+ .setMask(ctMark.getMask())
+ .build())
+ .build())
+ .setHasMask(true)
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmNxCtMark value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxCtMark(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxCtMark(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxCtMark(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxCtMark(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxCtMark(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxCtMark(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxCtMark(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxCtMark(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxCtMark(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxCtMark(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.CodecPreconditionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Nxm1Class;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.CtStateCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.CtStateCaseValueBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.nxm.nx.match.ct.state.grouping.CtStateValuesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxCtStateGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxCtStateKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.ct.state.grouping.NxmNxCtState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.ct.state.grouping.NxmNxCtStateBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxCtStateGrouping> matchGrouping = MatchUtil.CT_STATE_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.CT_STATE_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- CtStateCaseValueBuilder ctStateCaseValueBuilder = new CtStateCaseValueBuilder();
- CtStateValuesBuilder ctStateValuesBuilder = new CtStateValuesBuilder();
- ctStateValuesBuilder.setCtState(matchGrouping.get().getNxmNxCtState().getCtState());
- ctStateValuesBuilder.setMask(matchGrouping.get().getNxmNxCtState().getMask());
- ctStateCaseValueBuilder.setCtStateValues(ctStateValuesBuilder.build());
- MatchEntryBuilder ofMatch = MatchUtil.createDefaultMatchEntryBuilder(
+ final var ctState = matchGrouping.orElseThrow().getNxmNxCtState();
+ return MatchUtil.createDefaultMatchEntryBuilder(
org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxCtState.VALUE,
- Nxm1Class.VALUE, ctStateCaseValueBuilder.build());
- ofMatch.setHasMask(true);
- return ofMatch.build();
+ Nxm1Class.VALUE,
+ new CtStateCaseValueBuilder()
+ .setCtStateValues(new CtStateValuesBuilder()
+ .setCtState(ctState.getCtState())
+ .setMask(ctState.getMask())
+ .build())
+ .build())
+ .setHasMask(true)
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmNxCtState value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxCtState(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxCtState(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxCtState(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxCtState(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxCtState(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxCtState(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxCtState(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxCtState(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxCtState(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxCtState(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.CodecPreconditionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Nxm1Class;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.CtTpDstCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.CtTpDstCaseValueBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.nxm.nx.match.ct.tp.dst.grouping.CtTpDstValuesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxCtTpDstGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxCtTpDstKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.ct.tp.dst.grouping.NxmNxCtTpDst;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.ct.tp.dst.grouping.NxmNxCtTpDstBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxCtTpDstGrouping> matchGrouping = MatchUtil.CT_TP_DST_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.CT_TP_DST_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- CtTpDstCaseValueBuilder ctTpDstCaseValueBuilder = new CtTpDstCaseValueBuilder();
- CtTpDstValuesBuilder ctTpDstValuesBuilder = new CtTpDstValuesBuilder();
- ctTpDstValuesBuilder.setCtTpDst(matchGrouping.get().getNxmNxCtTpDst().getCtTpDst());
- ctTpDstCaseValueBuilder.setCtTpDstValues(ctTpDstValuesBuilder.build());
- MatchEntryBuilder ofMatch = MatchUtil
- .createDefaultMatchEntryBuilder(org.opendaylight.yang.gen.v1.urn
- .opendaylight.openflowjava.nx.match.rev140421.NxmNxCtTpSrc.VALUE,
- Nxm1Class.VALUE, ctTpDstCaseValueBuilder.build());
- return ofMatch.build();
+ return MatchUtil.createDefaultMatchEntryBuilder(org.opendaylight.yang.gen.v1.urn
+ .opendaylight.openflowjava.nx.match.rev140421.NxmNxCtTpSrc.VALUE,
+ Nxm1Class.VALUE, new CtTpDstCaseValueBuilder()
+ .setCtTpDstValues(new CtTpDstValuesBuilder()
+ .setCtTpDst(matchGrouping.orElseThrow().getNxmNxCtTpDst().getCtTpDst())
+ .build())
+ .build())
+ .build();
}
@Override
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmNxCtTpDst value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxCtTpDst(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxCtTpDst(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxCtTpDst(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxCtTpDst(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxCtTpDst(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxCtTpDst(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxCtTpDst(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxCtTpDst(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxCtTpDst(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxCtTpDst(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.CodecPreconditionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Nxm1Class;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.CtTpSrcCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.CtTpSrcCaseValueBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.nxm.nx.match.ct.tp.src.grouping.CtTpSrcValuesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxCtTpSrcGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxCtTpSrcKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.ct.tp.src.grouping.NxmNxCtTpSrc;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.ct.tp.src.grouping.NxmNxCtTpSrcBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxCtTpSrcGrouping> matchGrouping = MatchUtil.CT_TP_SRC_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.CT_TP_SRC_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- CtTpSrcCaseValueBuilder ctTpSrcCaseValueBuilder = new CtTpSrcCaseValueBuilder();
- CtTpSrcValuesBuilder ctTpSrcValuesBuilder = new CtTpSrcValuesBuilder();
- ctTpSrcValuesBuilder.setCtTpSrc(matchGrouping.get().getNxmNxCtTpSrc().getCtTpSrc());
- ctTpSrcCaseValueBuilder.setCtTpSrcValues(ctTpSrcValuesBuilder.build());
- MatchEntryBuilder ofMatch = MatchUtil
- .createDefaultMatchEntryBuilder(org.opendaylight.yang.gen.v1.urn
- .opendaylight.openflowjava.nx.match.rev140421.NxmNxCtTpSrc.VALUE,
- Nxm1Class.VALUE, ctTpSrcCaseValueBuilder.build());
- return ofMatch.build();
+ return MatchUtil.createDefaultMatchEntryBuilder(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxCtTpSrc.VALUE,
+ Nxm1Class.VALUE,
+ new CtTpSrcCaseValueBuilder()
+ .setCtTpSrcValues(new CtTpSrcValuesBuilder()
+ .setCtTpSrc(matchGrouping.orElseThrow().getNxmNxCtTpSrc().getCtTpSrc())
+ .build())
+ .build())
+ .build();
}
@Override
public ExtensionAugment<? extends Augmentation<Extension>> convert(final MatchEntry input, final MatchPath path) {
CtTpSrcCaseValue ctTpSrcCaseValue = (CtTpSrcCaseValue) input.getMatchEntryValue();
- NxmNxCtTpSrcBuilder ctTpSrcBuilder = new NxmNxCtTpSrcBuilder();
- ctTpSrcBuilder.setCtTpSrc(ctTpSrcCaseValue.getCtTpSrcValues().getCtTpSrc());
- return resolveAugmentation(ctTpSrcBuilder.build(), path, NxmNxCtTpSrcKey.VALUE);
+ return resolveAugmentation(new NxmNxCtTpSrcBuilder()
+ .setCtTpSrc(ctTpSrcCaseValue.getCtTpSrcValues().getCtTpSrc())
+ .build(), path, NxmNxCtTpSrcKey.VALUE);
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmNxCtTpSrc value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxCtTpSrc(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxCtTpSrc(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxCtTpSrc(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxCtTpSrc(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxCtTpSrc(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxCtTpSrc(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxCtTpSrc(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxCtTpSrc(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxCtTpSrc(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxCtTpSrc(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.CodecPreconditionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Nxm1Class;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.CtZoneCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.CtZoneCaseValueBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.nxm.nx.match.ct.zone.grouping.CtZoneValuesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxCtZoneGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxCtZoneKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.ct.zone.grouping.NxmNxCtZone;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.ct.zone.grouping.NxmNxCtZoneBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxCtZoneGrouping> matchGrouping = MatchUtil.CT_ZONE_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.CT_ZONE_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- CtZoneCaseValueBuilder ctZoneCaseValueBuilder = new CtZoneCaseValueBuilder();
- CtZoneValuesBuilder ctZoneValuesBuilder = new CtZoneValuesBuilder();
- ctZoneValuesBuilder.setCtZone(matchGrouping.get().getNxmNxCtZone().getCtZone());
- ctZoneCaseValueBuilder.setCtZoneValues(ctZoneValuesBuilder.build());
- MatchEntryBuilder ofMatch = MatchUtil
- .createDefaultMatchEntryBuilder(org.opendaylight.yang.gen.v1.urn
- .opendaylight.openflowjava.nx.match.rev140421.NxmNxCtZone.VALUE,
- Nxm1Class.VALUE, ctZoneCaseValueBuilder.build());
- return ofMatch.build();
+ return MatchUtil.createDefaultMatchEntryBuilder(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxCtZone.VALUE,
+ Nxm1Class.VALUE,
+ new CtZoneCaseValueBuilder()
+ .setCtZoneValues(new CtZoneValuesBuilder()
+ .setCtZone(matchGrouping.orElseThrow().getNxmNxCtZone().getCtZone())
+ .build())
+ .build())
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmNxCtZone value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxCtZone(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxCtZone(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxCtZone(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxCtZone(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxCtZone(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxCtZone(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxCtZone(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxCtZone(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxCtZone(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxCtZone(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.api.path.MatchPath;
import org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.CodecPreconditionException;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Nxm0Class;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.EthDstCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfEthDstGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfEthDstKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.eth.dst.grouping.NxmOfEthDst;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.eth.dst.grouping.NxmOfEthDstBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmOfEthDstGrouping> matchGrouping = MatchUtil.ETH_DST_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.ETH_DST_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- MacAddress macAddress = matchGrouping.get().getNxmOfEthDst().getMacAddress();
- EthDstCaseValueBuilder ethDstCaseValueBuilder = new EthDstCaseValueBuilder();
- ethDstCaseValueBuilder.setEthDstValues(new EthDstValuesBuilder()
- .setMacAddress(macAddress).build());
return MatchUtil.createDefaultMatchEntryBuilder(
- org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmOfEthDst.VALUE,
- Nxm0Class.VALUE, ethDstCaseValueBuilder.build()).build();
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmOfEthDst.VALUE,
+ Nxm0Class.VALUE,
+ new EthDstCaseValueBuilder()
+ .setEthDstValues(new EthDstValuesBuilder()
+ .setMacAddress(matchGrouping.orElseThrow().getNxmOfEthDst().getMacAddress())
+ .build())
+ .build())
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmOfEthDst value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfEthDst(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfEthDst(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmOfEthDst(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfEthDst(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmOfEthDst(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfEthDst(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfEthDst(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmOfEthDst(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfEthDst(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmOfEthDst(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.api.path.MatchPath;
import org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.CodecPreconditionException;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Nxm0Class;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.EthSrcCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfEthSrcGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfEthSrcKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.eth.src.grouping.NxmOfEthSrc;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.eth.src.grouping.NxmOfEthSrcBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmOfEthSrcGrouping> matchGrouping = MatchUtil.ETH_SRC_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.ETH_SRC_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- MacAddress macAddress = matchGrouping.get().getNxmOfEthSrc().getMacAddress();
- EthSrcCaseValueBuilder ethSrcCaseValueBuilder = new EthSrcCaseValueBuilder();
- ethSrcCaseValueBuilder.setEthSrcValues(new EthSrcValuesBuilder()
- .setMacAddress(macAddress).build());
return MatchUtil.createDefaultMatchEntryBuilder(
- org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmOfEthSrc.VALUE,
- Nxm0Class.VALUE, ethSrcCaseValueBuilder.build()).build();
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmOfEthSrc.VALUE,
+ Nxm0Class.VALUE,
+ new EthSrcCaseValueBuilder()
+ .setEthSrcValues(new EthSrcValuesBuilder()
+ .setMacAddress(matchGrouping.orElseThrow().getNxmOfEthSrc().getMacAddress())
+ .build())
+ .build())
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmOfEthSrc value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfEthSrc(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfEthSrc(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmOfEthSrc(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfEthSrc(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmOfEthSrc(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfEthSrc(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfEthSrc(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmOfEthSrc(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfEthSrc(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmOfEthSrc(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfEthTypeGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfEthTypeKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.eth.type.grouping.NxmOfEthType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.eth.type.grouping.NxmOfEthTypeBuilder;
import org.opendaylight.yangtools.yang.binding.Augmentation;
-import org.opendaylight.yangtools.yang.common.Uint16;
/**
* Convert to/from SAL flow model to openflowjava model for EthTypeCase.
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmOfEthTypeGrouping> matchGrouping = MatchUtil.ETH_TYPE_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.ETH_TYPE_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- Uint16 value = matchGrouping.get().getNxmOfEthType().getValue();
- EthTypeCaseValueBuilder ethTypeCaseValueBuilder = new EthTypeCaseValueBuilder();
- ethTypeCaseValueBuilder.setEthTypeValues(new EthTypeValuesBuilder()
- .setValue(value).build());
return MatchUtil.createDefaultMatchEntryBuilder(
- org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmOfEthType.VALUE,
- Nxm0Class.VALUE, ethTypeCaseValueBuilder.build()).build();
-
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmOfEthType.VALUE,
+ Nxm0Class.VALUE, new EthTypeCaseValueBuilder()
+ .setEthTypeValues(new EthTypeValuesBuilder()
+ .setValue(matchGrouping.orElseThrow().getNxmOfEthType().getValue())
+ .build())
+ .build())
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmOfEthType value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfEthType(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfEthType(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmOfEthType(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfEthType(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmOfEthType(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfEthType(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfEthType(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmOfEthType(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfEthType(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmOfEthType(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshFlagsGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshFlagsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nsh.flags.grouping.NxmNxNshFlags;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nsh.flags.grouping.NxmNxNshFlagsBuilder;
.setNshFlags(nshFlagsValues.getNshFlags())
.setMask(nshFlagsValues.getMask())
.build();
- return resolveAugmentation(
- nxmNxNshFlags,
- path,
- NxmNxNshFlagsKey.VALUE);
+ return resolveAugmentation(nxmNxNshFlags, path, NxmNxNshFlagsKey.VALUE);
}
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxNshFlagsGrouping> matchGrouping = MatchUtil.NSH_FLAGS_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.NSH_FLAGS_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- Uint8 flags = matchGrouping.get().getNxmNxNshFlags().getNshFlags();
- Uint8 mask = matchGrouping.get().getNxmNxNshFlags().getMask();
- return buildMatchEntry(flags, mask);
+ final var nshFlags = matchGrouping.orElseThrow().getNxmNxNshFlags();
+ return buildMatchEntry(nshFlags.getNshFlags(), nshFlags.getMask());
}
public static MatchEntry buildMatchEntry(final Uint8 flags, final Uint8 mask) {
value).setHasMask(mask != null).build();
}
- private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(
- final NxmNxNshFlags value,
+ private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmNxNshFlags value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshFlags(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshFlags(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
- new NxAugMatchNotifPacketInBuilder().setNxmNxNshFlags(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshFlags(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxNshFlags(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshFlags(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshFlags(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxNshFlags(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshFlags(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxNshFlags(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshMdtypeGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshMdtypeKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nsh.mdtype.grouping.NxmNxNshMdtype;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nsh.mdtype.grouping.NxmNxNshMdtypeBuilder;
NxmNxNshMdtype nxmNxNshMdtype = new NxmNxNshMdtypeBuilder()
.setValue(nshMdtypeValues.getValue())
.build();
- return resolveAugmentation(
- nxmNxNshMdtype,
- path,
- NxmNxNshMdtypeKey.VALUE);
+ return resolveAugmentation(nxmNxNshMdtype, path, NxmNxNshMdtypeKey.VALUE);
}
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxNshMdtypeGrouping> matchGrouping = MatchUtil.NSH_MDTYPE_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.NSH_MDTYPE_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- Uint8 value = matchGrouping.get().getNxmNxNshMdtype().getValue();
- return buildMatchEntry(value, null);
+ return buildMatchEntry(matchGrouping.orElseThrow().getNxmNxNshMdtype().getValue(), null);
}
public static MatchEntry buildMatchEntry(final Uint8 value, final Uint8 mask) {
entryValue).setHasMask(mask != null).build();
}
- private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(
- final NxmNxNshMdtype value,
+ private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmNxNshMdtype value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshMdtype(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshMdtype(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
- new NxAugMatchNotifPacketInBuilder().setNxmNxNshMdtype(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshMdtype(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxNshMdtype(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshMdtype(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshMdtype(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxNshMdtype(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshMdtype(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxNshMdtype(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshNpGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshNpKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nsh.np.grouping.NxmNxNshNp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nsh.np.grouping.NxmNxNshNpBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxNshNpGrouping> matchGrouping = MatchUtil.NSH_NP_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.NSH_NP_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- Uint8 value = matchGrouping.get().getNxmNxNshNp().getValue();
- return buildMatchEntry(value, null);
+ return buildMatchEntry(matchGrouping.orElseThrow().getNxmNxNshNp().getValue(), null);
}
public static MatchEntry buildMatchEntry(final Uint8 value, final Uint8 mask) {
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(
final NxmNxNshNp value, final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshNp(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshNp(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
- new NxAugMatchNotifPacketInBuilder().setNxmNxNshNp(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshNp(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxNshNp(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshNp(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshNp(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxNshNp(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshNp(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxNshNp(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev150225.experimenter.id.match.entry.ExperimenterIdCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.OfjAugNxExpMatch;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.exp.match.NxExpMatchEntryValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.exp.match.nx.exp.match.entry.value.NshTtlCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.exp.match.nx.exp.match.entry.value.NshTtlCaseValueBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.nxm.nx.match.nsh.ttl.grouping.NshTtlValues;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.nxm.nx.match.nsh.ttl.grouping.NshTtlValuesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.ExtensionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.grouping.Extension;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshTtlGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshTtlKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nsh.ttl.grouping.NxmNxNshTtl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nsh.ttl.grouping.NxmNxNshTtlBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxNshTtlGrouping> matchGrouping = MatchUtil.NSH_TTL_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.NSH_TTL_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- return buildMatchEntry(matchGrouping.get().getNxmNxNshTtl().getNshTtl(), null);
+ return buildMatchEntry(matchGrouping.orElseThrow().getNxmNxNshTtl().getNshTtl(), null);
}
public static MatchEntry buildMatchEntry(final Uint8 flags, final Uint8 mask) {
- NshTtlValues nshTtlValues = new NshTtlValuesBuilder().setNshTtl(flags).setMask(mask).build();
- NxExpMatchEntryValue value = new NshTtlCaseValueBuilder().setNshTtlValues(nshTtlValues).build();
return MatchUtil.createExperimenterMatchEntryBuilder(
- org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxNshTtl.VALUE,
- NiciraConstants.NX_NSH_VENDOR_ID,
- value).setHasMask(mask != null).build();
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxNshTtl.VALUE,
+ NiciraConstants.NX_NSH_VENDOR_ID,
+ new NshTtlCaseValueBuilder()
+ .setNshTtlValues(new NshTtlValuesBuilder().setNshTtl(flags).setMask(mask).build())
+ .build())
+ .setHasMask(mask != null)
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(
final NxmNxNshTtl value, final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshTtl(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshTtl(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
- new NxAugMatchNotifPacketInBuilder().setNxmNxNshTtl(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshTtl(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxNshTtl(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshTtl(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshTtl(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxNshTtl(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshTtl(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxNshTtl(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshc1Grouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshc1Key;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nshc._1.grouping.NxmNxNshc1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nshc._1.grouping.NxmNxNshc1Builder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxNshc1Grouping> matchGrouping = MatchUtil.NSC1_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ var matchGrouping = MatchUtil.NSC1_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- Uint32 value = matchGrouping.get().getNxmNxNshc1().getValue();
- Uint32 mask = matchGrouping.get().getNxmNxNshc1().getMask();
- MatchEntry matchEntry = buildMatchEntry(value, mask);
- return matchEntry;
+ final var nshc1 = matchGrouping.orElseThrow().getNxmNxNshc1();
+
+ return buildMatchEntry(nshc1.getValue(), nshc1.getMask());
}
public static MatchEntry buildMatchEntry(final Uint32 value, final Uint32 mask) {
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(
final NxmNxNshc1 value, final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshc1(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshc1(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxNshc1(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshc1(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxNshc1(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshc1(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshc1(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxNshc1(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshc1(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxNshc1(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshc2Grouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshc2Key;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nshc._2.grouping.NxmNxNshc2;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nshc._2.grouping.NxmNxNshc2Builder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxNshc2Grouping> matchGrouping = MatchUtil.NSC2_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ var matchGrouping = MatchUtil.NSC2_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- Uint32 value = matchGrouping.get().getNxmNxNshc2().getValue();
- Uint32 mask = matchGrouping.get().getNxmNxNshc2().getMask();
- MatchEntry matchEntry = buildMatchEntry(value, mask);
- return matchEntry;
+ final var nshc2 = matchGrouping.orElseThrow().getNxmNxNshc2();
+ return buildMatchEntry(nshc2.getValue(), nshc2.getMask());
}
public static MatchEntry buildMatchEntry(final Uint32 value, final Uint32 mask) {
NshcCaseValue nshcCaseValue = new NshcCaseValueBuilder().setNshc(value).setMask(mask).build();
return MatchUtil.createExperimenterMatchEntryBuilder(
org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxNshc2.VALUE,
- NiciraConstants.NX_NSH_VENDOR_ID,
- nshcCaseValue).setHasMask(mask != null).build();
+ NiciraConstants.NX_NSH_VENDOR_ID, nshcCaseValue)
+ .setHasMask(mask != null)
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(
final NxmNxNshc2 value, final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshc2(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshc2(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxNshc2(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshc2(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxNshc2(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshc2(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshc2(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxNshc2(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshc2(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxNshc2(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshc3Grouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshc3Key;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nshc._3.grouping.NxmNxNshc3;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nshc._3.grouping.NxmNxNshc3Builder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxNshc3Grouping> matchGrouping = MatchUtil.NSC3_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.NSC3_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- Uint32 value = matchGrouping.get().getNxmNxNshc3().getValue();
- Uint32 mask = matchGrouping.get().getNxmNxNshc3().getMask();
- MatchEntry matchEntry = buildMatchEntry(value, mask);
- return matchEntry;
+ final var nshc3 = matchGrouping.orElseThrow().getNxmNxNshc3();
+ return buildMatchEntry(nshc3.getValue(), nshc3.getMask());
}
public static MatchEntry buildMatchEntry(final Uint32 value, final Uint32 mask) {
- NshcCaseValue nshcCaseValue = new NshcCaseValueBuilder().setNshc(value).setMask(mask).build();
return MatchUtil.createExperimenterMatchEntryBuilder(
- org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxNshc3.VALUE,
- NiciraConstants.NX_NSH_VENDOR_ID,
- nshcCaseValue).setHasMask(mask != null).build();
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxNshc3.VALUE,
+ NiciraConstants.NX_NSH_VENDOR_ID,
+ new NshcCaseValueBuilder().setNshc(value).setMask(mask).build()).setHasMask(mask != null).build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(
final NxmNxNshc3 value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshc3(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshc3(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxNshc3(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshc3(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxNshc3(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshc3(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshc3(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxNshc3(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshc3(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxNshc3(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshc4Grouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNshc4Key;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nshc._4.grouping.NxmNxNshc4;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nshc._4.grouping.NxmNxNshc4Builder;
ExperimenterIdCase experimenterIdCase = (ExperimenterIdCase) input.getMatchEntryValue();
OfjAugNxExpMatch ofjAugNxExpMatch = experimenterIdCase.augmentation(OfjAugNxExpMatch.class);
NshcCaseValue nshcCaseValue = (NshcCaseValue) ofjAugNxExpMatch.getNxExpMatchEntryValue();
- NxmNxNshc4 nxmNxNshc4 = new NxmNxNshc4Builder()
- .setValue(nshcCaseValue.getNshc())
- .setMask(nshcCaseValue.getMask())
- .build();
- return resolveAugmentation(nxmNxNshc4, path, NxmNxNshc4Key.VALUE);
+ return resolveAugmentation(new NxmNxNshc4Builder()
+ .setValue(nshcCaseValue.getNshc())
+ .setMask(nshcCaseValue.getMask())
+ .build(), path, NxmNxNshc4Key.VALUE);
}
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxNshc4Grouping> matchGrouping = MatchUtil.NSC4_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.NSC4_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- Uint32 value = matchGrouping.get().getNxmNxNshc4().getValue();
- Uint32 mask = matchGrouping.get().getNxmNxNshc4().getMask();
- MatchEntry matchEntry = buildMatchEntry(value, mask);
- return matchEntry;
+ final var nshc4 = matchGrouping.orElseThrow().getNxmNxNshc4();
+ return buildMatchEntry(nshc4.getValue(), nshc4.getMask());
}
public static MatchEntry buildMatchEntry(final Uint32 value, final Uint32 mask) {
NshcCaseValue nshcCaseValue = new NshcCaseValueBuilder().setNshc(value).setMask(mask).build();
return MatchUtil.createExperimenterMatchEntryBuilder(
org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxNshc4.VALUE,
- NiciraConstants.NX_NSH_VENDOR_ID,
- nshcCaseValue).setHasMask(mask != null).build();
+ NiciraConstants.NX_NSH_VENDOR_ID, nshcCaseValue)
+ .setHasMask(mask != null)
+ .build();
}
- private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(
- final NxmNxNshc4 value,
+ private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmNxNshc4 value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshc4(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshc4(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxNshc4(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshc4(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxNshc4(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNshc4(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNshc4(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxNshc4(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNshc4(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxNshc4(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNsiGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNsiKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nsi.grouping.NxmNxNsi;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nsi.grouping.NxmNxNsiBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxNsiGrouping> matchGrouping = MatchUtil.NSI_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.NSI_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- Uint8 nsiValue = matchGrouping.get().getNxmNxNsi().getNsi();
- MatchEntry matchEntry = buildMatchEntry(nsiValue, null);
- return matchEntry;
+ return buildMatchEntry(matchGrouping.orElseThrow().getNxmNxNsi().getNsi(), null);
}
public static MatchEntry buildMatchEntry(final Uint8 nsi, final Uint8 mask) {
NsiCaseValue nsiCaseValue = new NsiCaseValueBuilder().setNsiValues(nsiValues).build();
return MatchUtil.createExperimenterMatchEntryBuilder(
org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxNsi.VALUE,
- NiciraConstants.NX_NSH_VENDOR_ID,
- nsiCaseValue).setHasMask(mask != null).build();
+ NiciraConstants.NX_NSH_VENDOR_ID, nsiCaseValue)
+ .setHasMask(mask != null)
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmNxNsi value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNsi(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNsi(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxNsi(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNsi(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxNsi(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNsi(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNsi(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxNsi(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNsi(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxNsi(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.OfjAugNxExpMatch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.exp.match.nx.exp.match.entry.value.NspCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.exp.match.nx.exp.match.entry.value.NspCaseValueBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.nxm.nx.match.nsp.grouping.NspValues;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.nxm.nx.match.nsp.grouping.NspValuesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.ExtensionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.grouping.Extension;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNspGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxNspKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nsp.grouping.NxmNxNsp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.nsp.grouping.NxmNxNspBuilder;
OfjAugNxExpMatch ofjAugNxExpMatch = experimenterIdCase.augmentation(OfjAugNxExpMatch.class);
NspCaseValue nshNspCaseValue = (NspCaseValue) ofjAugNxExpMatch.getNxExpMatchEntryValue();
- return resolveAugmentation(
- new NxmNxNspBuilder().setValue(nshNspCaseValue.getNspValues().getNsp()).build(),
- path,
- NxmNxNspKey.VALUE);
+ return resolveAugmentation(new NxmNxNspBuilder().setValue(nshNspCaseValue.getNspValues().getNsp()).build(),
+ path, NxmNxNspKey.VALUE);
}
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxNspGrouping> matchGrouping = MatchUtil.NSP_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.NSP_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- Uint32 nspValue = matchGrouping.get().getNxmNxNsp().getValue();
- MatchEntry matchEntry = buildMatchEntry(nspValue, null);
- return matchEntry;
+ return buildMatchEntry(matchGrouping.orElseThrow().getNxmNxNsp().getValue(), null);
}
public static MatchEntry buildMatchEntry(final Uint32 nsp, final Uint32 mask) {
- NspValues nspValues = new NspValuesBuilder().setNsp(nsp).setMask(mask).build();
- NspCaseValue nspCaseValue = new NspCaseValueBuilder().setNspValues(nspValues).build();
return MatchUtil.createExperimenterMatchEntryBuilder(
- org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxNsp.VALUE,
- NiciraConstants.NX_NSH_VENDOR_ID,
- nspCaseValue).setHasMask(mask != null).build();
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxNsp.VALUE,
+ NiciraConstants.NX_NSH_VENDOR_ID,
+ new NspCaseValueBuilder().setNspValues(new NspValuesBuilder().setNsp(nsp).setMask(mask).build()).build())
+ .setHasMask(mask != null)
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmNxNsp value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNsp(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNsp(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxNsp(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNsp(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxNsp(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxNsp(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxNsp(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxNsp(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxNsp(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxNsp(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfInPortGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfInPortKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.in.port.grouping.OfInPortBuilder;
import org.opendaylight.yangtools.yang.binding.Augmentation;
-import org.opendaylight.yangtools.yang.common.Uint16;
-public class NxmInPortConvertor implements ConvertorToOFJava<MatchEntry>,
- ConvertorFromOFJava<MatchEntry, MatchPath> {
+public class NxmInPortConvertor implements ConvertorToOFJava<MatchEntry>, ConvertorFromOFJava<MatchEntry, MatchPath> {
@Override
public ExtensionAugment<? extends Augmentation<Extension>> convert(
final MatchEntry input, final MatchPath path) {
- OfInPortCaseValue inPortCaseValue = (OfInPortCaseValue) input
- .getMatchEntryValue();
+ OfInPortCaseValue inPortCaseValue = (OfInPortCaseValue) input.getMatchEntryValue();
return NxmInPortConvertor.resolveAugmentation(new OfInPortBuilder()
.setValue(inPortCaseValue.getNxmOfInPortValues().getValue())
.build(), path, NxmOfInPortKey.VALUE);
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmOfInPortGrouping> matchGrouping = MatchUtil.NXM_OF_INPORT_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.NXM_OF_INPORT_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- Uint16 value = matchGrouping.get().getOfInPort().getValue();
- OfInPortCaseValueBuilder inPortCaseValueBuilder = new OfInPortCaseValueBuilder();
- inPortCaseValueBuilder.setNxmOfInPortValues(
- new NxmOfInPortValuesBuilder().setValue(value).build());
return MatchUtil.createDefaultMatchEntryBuilder(
org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmOfInPort.VALUE,
- Nxm0Class.VALUE, inPortCaseValueBuilder.build())
+ Nxm0Class.VALUE,
+ new OfInPortCaseValueBuilder()
+ .setNxmOfInPortValues(new NxmOfInPortValuesBuilder()
+ .setValue(matchGrouping.orElseThrow().getOfInPort().getValue())
+ .build())
+ .build())
.build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(
final org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of
.in.port.grouping.OfInPort value, final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setOfInPort(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setOfInPort(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
- new NxAugMatchNotifPacketInBuilder().setOfInPort(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setOfInPort(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setOfInPort(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setOfInPort(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setOfInPort(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setOfInPort(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setOfInPort(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setOfInPort(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.CodecPreconditionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Nxm1Class;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.PktMarkCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.PktMarkCaseValueBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.nxm.nx.match.pkt.mark.grouping.PktMarkValuesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxPktMarkGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxPktMarkKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.pkt.mark.grouping.NxmNxPktMark;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.pkt.mark.grouping.NxmNxPktMarkBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxPktMarkGrouping> matchGrouping = MatchUtil.PKT_MARK_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.PKT_MARK_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- PktMarkCaseValueBuilder pktMarkCaseValueBuilder = new PktMarkCaseValueBuilder();
- PktMarkValuesBuilder pktMarkValuesBuilder = new PktMarkValuesBuilder();
- pktMarkValuesBuilder.setPktMark(matchGrouping.get().getNxmNxPktMark().getPktMark());
- pktMarkValuesBuilder.setMask(matchGrouping.get().getNxmNxPktMark().getMask());
- pktMarkCaseValueBuilder.setPktMarkValues(pktMarkValuesBuilder.build());
- MatchEntryBuilder ofMatch = MatchUtil
- .createDefaultMatchEntryBuilder(org.opendaylight.yang.gen.v1.urn
- .opendaylight.openflowjava.nx.match.rev140421.NxmNxPktMark.VALUE,
- Nxm1Class.VALUE, pktMarkCaseValueBuilder.build());
- return ofMatch.build();
+ final var pktMark = matchGrouping.orElseThrow().getNxmNxPktMark();
+
+ return MatchUtil.createDefaultMatchEntryBuilder(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxPktMark.VALUE,
+ Nxm1Class.VALUE,
+ new PktMarkCaseValueBuilder()
+ .setPktMarkValues(new PktMarkValuesBuilder()
+ .setPktMark(pktMark.getPktMark())
+ .setMask(pktMark.getMask())
+ .build())
+ .build())
+ .build();
}
@Override
public ExtensionAugment<? extends Augmentation<Extension>> convert(final MatchEntry input, final MatchPath path) {
- PktMarkCaseValue pktMarkCaseValue = (PktMarkCaseValue) input.getMatchEntryValue();
- NxmNxPktMarkBuilder pktMarkBuilder = new NxmNxPktMarkBuilder();
- pktMarkBuilder.setPktMark(pktMarkCaseValue.getPktMarkValues().getPktMark());
- pktMarkBuilder.setMask(pktMarkCaseValue.getPktMarkValues().getMask());
- return resolveAugmentation(pktMarkBuilder.build(), path, NxmNxPktMarkKey.VALUE);
+ final var pktMark = ((PktMarkCaseValue) input.getMatchEntryValue()).getPktMarkValues();
+ return resolveAugmentation(new NxmNxPktMarkBuilder()
+ .setPktMark(pktMark.getPktMark())
+ .setMask(pktMark.getMask())
+ .build(), path, NxmNxPktMarkKey.VALUE);
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmNxPktMark value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxPktMark(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxPktMark(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxPktMark(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxPktMark(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxPktMark(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxPktMark(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxPktMark(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxPktMark(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxPktMark(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxPktMark(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowjava.nx.codec.match.NiciraMatchCodecs;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxReg5Key;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxReg6Key;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxReg7Key;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxRegGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.reg.grouping.NxmNxReg;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.reg.grouping.NxmNxRegBuilder;
import org.opendaylight.yangtools.yang.binding.Augmentation;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxRegGrouping> matchGrouping = MatchUtil.REG_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.REG_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- NxmNxReg nxmNxReg = matchGrouping.get().getNxmNxReg();
- RegValuesBuilder regValuesBuilder = new RegValuesBuilder()
- .setValue(nxmNxReg.getValue())
- .setMask(nxmNxReg.getMask());
+ final var nxmNxReg = matchGrouping.orElseThrow().getNxmNxReg();
- RegCaseValueBuilder regCaseValueBuilder = new RegCaseValueBuilder();
- regCaseValueBuilder.setRegValues(regValuesBuilder.build());
- return MatchUtil.createDefaultMatchEntryBuilder(nxmNxReg.getReg(),
- Nxm1Class.VALUE,
- regCaseValueBuilder.build())
+ return MatchUtil.createDefaultMatchEntryBuilder(nxmNxReg.getReg(), Nxm1Class.VALUE,
+ new RegCaseValueBuilder()
+ .setRegValues(new RegValuesBuilder().setValue(nxmNxReg.getValue()).setMask(nxmNxReg.getMask()).build())
+ .build())
.setHasMask(nxmNxReg.getMask() != null)
.build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmNxReg nxmNxReg,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxReg(nxmNxReg).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxReg(nxmNxReg).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxReg(nxmNxReg).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxReg(nxmNxReg).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxReg(nxmNxReg).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxReg(nxmNxReg).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxReg(nxmNxReg).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxReg(nxmNxReg).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxReg(nxmNxReg).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxReg(nxmNxReg).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.CodecPreconditionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Nxm0Class;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.TcpDstCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.TcpDstCaseValueBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.nxm.of.match.tcp.dst.grouping.TcpDstValuesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfTcpDstGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfTcpDstKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.tcp.dst.grouping.NxmOfTcpDst;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.tcp.dst.grouping.NxmOfTcpDstBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmOfTcpDstGrouping> matchGrouping = MatchUtil.TCP_DST_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.TCP_DST_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- TcpDstCaseValueBuilder tcpDstCaseValueBuilder = new TcpDstCaseValueBuilder();
- TcpDstValuesBuilder tcpDstValuesBuilder = new TcpDstValuesBuilder();
- tcpDstValuesBuilder.setPort(matchGrouping.get().getNxmOfTcpDst().getPort());
- tcpDstValuesBuilder.setMask(matchGrouping.get().getNxmOfTcpDst().getMask());
- tcpDstCaseValueBuilder.setTcpDstValues(tcpDstValuesBuilder.build());
- MatchEntryBuilder ofMatch = MatchUtil
- .createDefaultMatchEntryBuilder(org.opendaylight.yang.gen.v1.urn
- .opendaylight.openflowjava.nx.match.rev140421.NxmOfTcpDst.VALUE,
- Nxm0Class.VALUE, tcpDstCaseValueBuilder.build());
- ofMatch.setHasMask(true);
- return ofMatch.build();
+ final var tcpDst = matchGrouping.orElseThrow().getNxmOfTcpDst();
+ return MatchUtil.createDefaultMatchEntryBuilder(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmOfTcpDst.VALUE,
+ Nxm0Class.VALUE,
+ new TcpDstCaseValueBuilder()
+ .setTcpDstValues(new TcpDstValuesBuilder()
+ .setPort(tcpDst.getPort())
+ .setMask(tcpDst.getMask())
+ .build())
+ .build())
+ .setHasMask(true)
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmOfTcpDst value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfTcpDst(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfTcpDst(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmOfTcpDst(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfTcpDst(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmOfTcpDst(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfTcpDst(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfTcpDst(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmOfTcpDst(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfTcpDst(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmOfTcpDst(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.CodecPreconditionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Nxm0Class;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.TcpSrcCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.TcpSrcCaseValueBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.nxm.of.match.tcp.src.grouping.TcpSrcValuesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfTcpSrcGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfTcpSrcKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.tcp.src.grouping.NxmOfTcpSrc;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.tcp.src.grouping.NxmOfTcpSrcBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmOfTcpSrcGrouping> matchGrouping = MatchUtil.TCP_SRC_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.TCP_SRC_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- TcpSrcCaseValueBuilder tcpSrcCaseValueBuilder = new TcpSrcCaseValueBuilder();
- TcpSrcValuesBuilder tcpSrcValuesBuilder = new TcpSrcValuesBuilder();
- tcpSrcValuesBuilder.setPort(matchGrouping.get().getNxmOfTcpSrc().getPort());
- tcpSrcValuesBuilder.setMask(matchGrouping.get().getNxmOfTcpSrc().getMask());
- tcpSrcCaseValueBuilder.setTcpSrcValues(tcpSrcValuesBuilder.build());
- MatchEntryBuilder ofMatch = MatchUtil
- .createDefaultMatchEntryBuilder(org.opendaylight.yang.gen.v1.urn
- .opendaylight.openflowjava.nx.match.rev140421.NxmOfTcpSrc.VALUE,
- Nxm0Class.VALUE, tcpSrcCaseValueBuilder.build());
- ofMatch.setHasMask(true);
- return ofMatch.build();
+ final var tcpSrc = matchGrouping.orElseThrow().getNxmOfTcpSrc();
+ return MatchUtil.createDefaultMatchEntryBuilder(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmOfTcpSrc.VALUE,
+ Nxm0Class.VALUE,
+ new TcpSrcCaseValueBuilder()
+ .setTcpSrcValues(new TcpSrcValuesBuilder().setPort(tcpSrc.getPort()).setMask(tcpSrc.getMask()).build())
+ .build())
+ .setHasMask(true)
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmOfTcpSrc value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfTcpSrc(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfTcpSrc(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmOfTcpSrc(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfTcpSrc(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmOfTcpSrc(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfTcpSrc(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfTcpSrc(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmOfTcpSrc(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfTcpSrc(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmOfTcpSrc(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxTunIdGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmNxTunIdKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.tun.id.grouping.NxmNxTunId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.nx.tun.id.grouping.NxmNxTunIdBuilder;
import org.opendaylight.yangtools.yang.binding.Augmentation;
-import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Convert to/from SAL flow model to openflowjava model for TunIdCase.
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxTunIdGrouping> matchGrouping = MatchUtil.TUN_ID_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ var matchGrouping = MatchUtil.TUN_ID_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- Uint64 value = matchGrouping.get().getNxmNxTunId().getValue();
-
- TunIdCaseValueBuilder tunnelIdCaseBuilder = new TunIdCaseValueBuilder();
-
- TunIdValuesBuilder tunnelIdBuilder = new TunIdValuesBuilder();
- tunnelIdBuilder.setValue(value);
- tunnelIdCaseBuilder.setTunIdValues(tunnelIdBuilder.build());
return MatchUtil.createDefaultMatchEntryBuilder(
org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxTunId.VALUE,
- Nxm1Class.VALUE, tunnelIdCaseBuilder.build()).build();
-
+ Nxm1Class.VALUE,
+ new TunIdCaseValueBuilder().setTunIdValues(new TunIdValuesBuilder()
+ .setValue(matchGrouping.orElseThrow().getNxmNxTunId().getValue())
+ .build())
+ .build())
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmNxTunId value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxTunId(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxTunId(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmNxTunId(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxTunId(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmNxTunId(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmNxTunId(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmNxTunId(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmNxTunId(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmNxTunId(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmNxTunId(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.CodecPreconditionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Nxm0Class;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.UdpDstCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.UdpDstCaseValueBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.nxm.of.match.udp.dst.grouping.UdpDstValuesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfUdpDstGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfUdpDstKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.udp.dst.grouping.NxmOfUdpDst;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.udp.dst.grouping.NxmOfUdpDstBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmOfUdpDstGrouping> matchGrouping = MatchUtil.UDP_DST_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.UDP_DST_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- UdpDstCaseValueBuilder udpDstCaseValueBuilder = new UdpDstCaseValueBuilder();
- UdpDstValuesBuilder udpDstValuesBuilder = new UdpDstValuesBuilder();
- udpDstValuesBuilder.setPort(matchGrouping.get().getNxmOfUdpDst().getPort());
- udpDstValuesBuilder.setMask(matchGrouping.get().getNxmOfUdpDst().getMask());
- udpDstCaseValueBuilder.setUdpDstValues(udpDstValuesBuilder.build());
- MatchEntryBuilder ofMatch = MatchUtil
- .createDefaultMatchEntryBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight
- .openflowjava.nx.match.rev140421.NxmOfUdpDst.VALUE,
- Nxm0Class.VALUE, udpDstCaseValueBuilder.build());
- ofMatch.setHasMask(true);
- return ofMatch.build();
+ final var udpDst = matchGrouping.orElseThrow().getNxmOfUdpDst();
+ return MatchUtil.createDefaultMatchEntryBuilder(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmOfUdpDst.VALUE,
+ Nxm0Class.VALUE,
+ new UdpDstCaseValueBuilder()
+ .setUdpDstValues(new UdpDstValuesBuilder().setPort(udpDst.getPort()).setMask(udpDst.getMask()).build())
+ .build())
+ .setHasMask(true)
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmOfUdpDst value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfUdpDst(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfUdpDst(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmOfUdpDst(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfUdpDst(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmOfUdpDst(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfUdpDst(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfUdpDst(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmOfUdpDst(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfUdpDst(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmOfUdpDst(value).build(), key);
+ };
}
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.CodecPreconditionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Nxm0Class;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.UdpSrcCaseValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.aug.nx.match.UdpSrcCaseValueBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.ofj.nxm.of.match.udp.src.grouping.UdpSrcValuesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchPacketInMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchRpcGetFlowStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfUdpSrcGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxmOfUdpSrcKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.udp.src.grouping.NxmOfUdpSrc;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.udp.src.grouping.NxmOfUdpSrcBuilder;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmOfUdpSrcGrouping> matchGrouping = MatchUtil.UDP_SRC_RESOLVER.findExtension(extension);
- if (!matchGrouping.isPresent()) {
+ final var matchGrouping = MatchUtil.UDP_SRC_RESOLVER.findExtension(extension);
+ if (matchGrouping.isEmpty()) {
throw new CodecPreconditionException(extension);
}
- UdpSrcCaseValueBuilder udpSrcCaseValueBuilder = new UdpSrcCaseValueBuilder();
- UdpSrcValuesBuilder udpSrcValuesBuilder = new UdpSrcValuesBuilder();
- udpSrcValuesBuilder.setPort(matchGrouping.get().getNxmOfUdpSrc().getPort());
- udpSrcValuesBuilder.setMask(matchGrouping.get().getNxmOfUdpSrc().getMask());
- udpSrcCaseValueBuilder.setUdpSrcValues(udpSrcValuesBuilder.build());
- MatchEntryBuilder ofMatch = MatchUtil
- .createDefaultMatchEntryBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight
- .openflowjava.nx.match.rev140421.NxmOfUdpSrc.VALUE,
- Nxm0Class.VALUE, udpSrcCaseValueBuilder.build());
- ofMatch.setHasMask(true);
- return ofMatch.build();
+ final var udpSrc = matchGrouping.orElseThrow().getNxmOfUdpSrc();
+ return MatchUtil.createDefaultMatchEntryBuilder(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmOfUdpSrc.VALUE,
+ Nxm0Class.VALUE,
+ new UdpSrcCaseValueBuilder()
+ .setUdpSrcValues(new UdpSrcValuesBuilder().setPort(udpSrc.getPort()).setMask(udpSrc.getMask()).build())
+ .build())
+ .setHasMask(true)
+ .build();
}
private static ExtensionAugment<? extends Augmentation<Extension>> resolveAugmentation(final NxmOfUdpSrc value,
final MatchPath path, final ExtensionKey key) {
- switch (path) {
- case FLOWS_STATISTICS_UPDATE_MATCH:
- return new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
- new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfUdpSrc(value).build(), key);
- case FLOWS_STATISTICS_RPC_MATCH:
- return new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
- new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfUdpSrc(value).build(), key);
- case PACKET_RECEIVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifPacketIn.class, new NxAugMatchNotifPacketInBuilder()
- .setNxmOfUdpSrc(value).build(), key);
- case SWITCH_FLOW_REMOVED_MATCH:
- return new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
- new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfUdpSrc(value).build(), key);
- case PACKET_IN_MESSAGE_MATCH:
- return new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
- new NxAugMatchPacketInMessageBuilder().setNxmOfUdpSrc(value).build(), key);
- default:
- throw new CodecPreconditionException(path);
- }
+ return switch (path) {
+ case FLOWS_STATISTICS_UPDATE_MATCH -> new ExtensionAugment<>(NxAugMatchNodesNodeTableFlow.class,
+ new NxAugMatchNodesNodeTableFlowBuilder().setNxmOfUdpSrc(value).build(), key);
+ case FLOWS_STATISTICS_RPC_MATCH -> new ExtensionAugment<>(NxAugMatchRpcGetFlowStats.class,
+ new NxAugMatchRpcGetFlowStatsBuilder().setNxmOfUdpSrc(value).build(), key);
+ case PACKET_RECEIVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifPacketIn.class,
+ new NxAugMatchNotifPacketInBuilder().setNxmOfUdpSrc(value).build(), key);
+ case SWITCH_FLOW_REMOVED_MATCH -> new ExtensionAugment<>(NxAugMatchNotifSwitchFlowRemoved.class,
+ new NxAugMatchNotifSwitchFlowRemovedBuilder().setNxmOfUdpSrc(value).build(), key);
+ case PACKET_IN_MESSAGE_MATCH -> new ExtensionAugment<>(NxAugMatchPacketInMessage.class,
+ new NxAugMatchPacketInMessageBuilder().setNxmOfUdpSrc(value).build(), key);
+ };
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.onf.converter;
import java.util.Collection;
flowModInputs = Optional.empty();
}
- if (!flowModInputs.isPresent()) {
+ if (flowModInputs.isEmpty()) {
throw new ConversionException("BundleFlowCase conversion unsuccessful.");
}
- final List<FlowModInputBuilder> inputs = flowModInputs.get();
+ final List<FlowModInputBuilder> inputs = flowModInputs.orElseThrow();
if (inputs.size() != 1) {
throw new ConversionException(
"BundleFlowCase conversion unsuccessful - not able to convert to multiple flows.");
groupModInput = Optional.empty();
}
- if (!groupModInput.isPresent()) {
+ if (groupModInput.isEmpty()) {
throw new ConversionException("BundleGroupCase conversion unsuccessful.");
}
return new BundleGroupModCaseBuilder()
- .setGroupModCaseData(new GroupModCaseDataBuilder(groupModInput.get().setXid(data.getXid()).build())
- .build())
- .build();
+ .setGroupModCaseData(new GroupModCaseDataBuilder(groupModInput.orElseThrow().setXid(data.getXid()).build())
+ .build())
+ .build();
}
private static BundlePortModCase convertBundlePortCase(final BundleInnerMessage messageCase,
portModInput = Optional.empty();
}
- if (!portModInput.isPresent()) {
+ if (portModInput.isEmpty()) {
throw new ConversionException("BundlePortCase conversion unsuccessful.");
}
return new BundlePortModCaseBuilder()
- .setPortModCaseData(new PortModCaseDataBuilder(portModInput.get()).setXid(data.getXid()).build())
- .build();
+ .setPortModCaseData(new PortModCaseDataBuilder(portModInput.orElseThrow()).setXid(data.getXid()).build())
+ .build();
}
@Override
}
final Optional<F> firstOptional = source.values().stream().findFirst();
-
- if (!firstOptional.isPresent()) {
+ if (firstOptional.isEmpty()) {
LOG.trace("Cannot extract type from empty collection");
return result;
}
- final F first = firstOptional.get();
+ final F first = firstOptional.orElseThrow();
- final Class<?> type = first instanceof DataContainer ? ((DataContainer) first).implementedInterface()
+ final Class<?> type = first instanceof DataContainer dataContainer ? dataContainer.implementedInterface()
: first.getClass();
if (type == null) {
}
final Optional<F> firstOptional = source.stream().findFirst();
-
- if (!firstOptional.isPresent()) {
+ if (firstOptional.isEmpty()) {
LOG.trace("Cannot extract type from empty collection");
return result;
}
- final F first = firstOptional.get();
-
- final Class<?> type = first instanceof DataContainer ? ((DataContainer) first).implementedInterface()
+ final F first = firstOptional.orElseThrow();
+ final Class<?> type = first instanceof DataContainer dataContainer ? dataContainer.implementedInterface()
: first.getClass();
if (type == null) {
* }
* </pre>
*/
-public class GroupDescStatsResponseConvertor extends Convertor<List<GroupDesc>, List<GroupDescStats>,
- VersionConvertorData> {
-
+public class GroupDescStatsResponseConvertor
+ extends Convertor<List<GroupDesc>, List<GroupDescStats>, VersionConvertorData> {
private static final Set<Class<?>> TYPES = Set.of(GroupDesc.class);
private org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.Buckets toSALBucketsDesc(
int actionKey = 0;
- for (org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action action :
- convertedSalActions.get()) {
- ActionBuilder wrappedAction = new ActionBuilder();
- wrappedAction.setAction(action);
- wrappedAction.withKey(new ActionKey(actionKey));
- wrappedAction.setOrder(actionKey);
- actions.add(wrappedAction.build());
+ for (var action : convertedSalActions.orElseThrow()) {
+ actions.add(new ActionBuilder()
+ .setAction(action)
+ .withKey(new ActionKey(actionKey))
+ .setOrder(actionKey)
+ .build());
actionKey++;
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action;
import com.google.common.collect.Ordering;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Collections;
import java.util.List;
-import java.util.Optional;
import java.util.Set;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases.SalToOfCopyTtlInCase;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases.SalToOfCopyTtlOutCase;
// Try to convert action grouping using converters from openflowplugin-extension
.addCase(new SalToOfGeneralExtensionGroupingCase());
- private static final Set<Class<?>> TYPES = Collections.singleton(org.opendaylight.yang.gen.v1.urn.opendaylight
+ private static final Set<Class<?>> TYPES = Set.of(org.opendaylight.yang.gen.v1.urn.opendaylight
.action.types.rev131112.action.list.Action.class);
private static final Ordering<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112
.action.list.Action> ACTION_ORDERING = Ordering.from(OrderComparator.build());
}
@Override
- public List<Action> convert(Collection<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action
- .list.Action> source, ActionConvertorData data) {
+ public List<Action> convert(final Collection<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112
+ .action.list.Action> source, final ActionConvertorData data) {
// Prepare list of converted actions
- final List<Action> result = new ArrayList<>();
+ final var result = new ArrayList<Action>();
// Iterate over SAL actions, run them through tokenizer and then add them to list of converted actions
if (source != null) {
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>
- sortedActions = ACTION_ORDERING.sortedCopy(source);
-
- for (final org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action action :
- sortedActions) {
- final Optional<Action> convertedAction = PROCESSOR.process(action.getAction(), data,
- getConvertorExecutor());
-
- if (convertedAction.isPresent()) {
- result.add(convertedAction.get());
- }
+ for (var action : ACTION_ORDERING.sortedCopy(source)) {
+ PROCESSOR.process(action.getAction(), data, getConvertorExecutor()).ifPresent(result::add);
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Collections;
import java.util.List;
-import java.util.Optional;
import java.util.Set;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
import org.opendaylight.openflowplugin.openflow.md.core.extension.ActionExtensionHelper;
.addCase(new OfToSalSetVlanPcpCase())
.addCase(new OfToSalSetVlanIdCase())
.addCase(new OfToSalStripVlanCase());
- private static final Set<Class<?>> TYPES = Collections.singleton(Action.class);
+ private static final Set<Class<?>> TYPES = Set.of(Action.class);
@Override
public Collection<Class<?>> getTypes() {
@Override
public List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action>
- convert(List<Action> source, ActionResponseConvertorData data) {
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action> result =
- new ArrayList<>();
- final OpenflowVersion ofVersion = OpenflowVersion.get(data.getVersion());
+ convert(final List<Action> source, final ActionResponseConvertorData data) {
+ final var result =
+ new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action>();
// Iterate over Openflow actions, run them through tokenizer and then add them to list of converted actions
if (source != null) {
- for (final Action action : source) {
- final Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action>
- convertedAction = PROCESSOR.process(action.getActionChoice(), data, getConvertorExecutor());
-
+ final var ofVersion = OpenflowVersion.get(data.getVersion());
+ for (var action : source) {
+ final var convertedAction = PROCESSOR.process(action.getActionChoice(), data, getConvertorExecutor());
if (convertedAction.isPresent()) {
- result.add(convertedAction.get());
+ result.add(convertedAction.orElseThrow());
} else {
/*
* TODO: EXTENSION PROPOSAL (action, OFJava to MD-SAL)
* - we might also need a way on how to identify exact type of augmentation to be
* used as match can be bound to multiple models
*/
- org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action processedAction =
- ActionExtensionHelper.processAlienAction(action, ofVersion, data.getActionPath());
-
+ var processedAction = ActionExtensionHelper.processAlienAction(action, ofVersion,
+ data.getActionPath());
if (processedAction != null) {
result.add(processedAction);
}
.build())
.build());
if (optional.isPresent()) {
- list.add(toFlowModInput(optional.get(), versionDatapathIdConverterData));
+ list.add(toFlowModInput(optional.orElseThrow(), versionDatapathIdConverterData));
}
} else {
// create 2 flows
Optional<? extends Flow> optional1 = injectMatchAndAction(srcFlow,
new MatchBuilder(srcMatch).setVlanMatch(VLAN_MATCH_FALSE).build());
if (optional1.isPresent()) {
- list.add(toFlowModInput(optional1.get(), versionDatapathIdConverterData));
+ list.add(toFlowModInput(optional1.orElseThrow(), versionDatapathIdConverterData));
}
//flow2
Optional<? extends Flow> optional2 = injectMatchToFlow(srcFlow,
new MatchBuilder(srcMatch).setVlanMatch(VLAN_MATCH_TRUE).build());
if (optional2.isPresent()) {
- list.add(toFlowModInput(optional2.get(), versionDatapathIdConverterData));
+ list.add(toFlowModInput(optional2.orElseThrow(), versionDatapathIdConverterData));
}
}
return list;
for (var srcInstruction : srcInstructionList.values()) {
final var curSrcInstruction = srcInstruction.getInstruction();
- if (curSrcInstruction instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026
- .instruction.instruction.ApplyActionsCase) {
- final var applyActionscase = (org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
- .rev131026.instruction.instruction.ApplyActionsCase) curSrcInstruction;
+ if (curSrcInstruction
+ instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026
+ .instruction.instruction.ApplyActionsCase applyActionscase) {
final var srcActionList = applyActionscase.getApplyActions().nonnullAction();
int offset = 0;
public static <F, T> void inject(final Optional<F> source, final T target, final Uint8 version) {
F sourceResult;
if (source.isPresent()) {
- sourceResult = source.get();
+ sourceResult = source.orElseThrow();
} else if (version.equals(EncodeConstants.OF_VERSION_1_0)) {
sourceResult = (F) FlowFlagsV10Convertor.defaultResult();
} else {
Uint8 ipProtocol = null;
if (matchBuilderOptional.isPresent()) {
- final MatchBuilder matchBuilder = matchBuilderOptional.get();
+ final MatchBuilder matchBuilder = matchBuilderOptional.orElseThrow();
final IpMatch ipMatch = matchBuilder.getIpMatch();
if (ipMatch != null) {
ipProtocol = ipMatch.getIpProtocol();
flowStats.getMatch(), data);
if (matchBuilderOptional.isPresent()) {
- final MatchBuilder matchBuilder = matchBuilderOptional.get();
+ final MatchBuilder matchBuilder = matchBuilderOptional.orElseThrow();
final AugmentTuple<Match> matchExtensionWrap =
MatchExtensionHelper.processAllExtensions(
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
* Utility class for converting a MD-SAL Flow into the OF flow mod.
*/
public class MatchConvertor extends Convertor<Match, List<MatchEntry>, VersionConvertorData> {
- private static final List<Class<?>> TYPES = Arrays.asList(
+ private static final List<Class<?>> TYPES = List.of(
Match.class,
org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Match.class,
org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.mod.removed.Match.class,
private static void layer3Match(final List<MatchEntry> matchEntryList, final Layer3Match layer3Match,
final ConvertorExecutor converterExecutor,
final ExtensionConverterProvider extensionConvertorProvider) {
- java.util.Optional<List<MatchEntry>> result = LAYER3_PROCESSOR.process(layer3Match, converterExecutor
- );
-
- if (result.isPresent()) {
- matchEntryList.addAll(result.get());
- }
+ LAYER3_PROCESSOR.process(layer3Match, converterExecutor).ifPresent(matchEntryList::addAll);
}
private static void layer4Match(final List<MatchEntry> matchEntryList, final Layer4Match layer4Match,
final ConvertorExecutor converterExecutor, final ExtensionConverterProvider extensionConvertorProvider) {
- java.util.Optional<List<MatchEntry>> result = LAYER4_PROCESSOR.process(layer4Match, converterExecutor
- );
-
- if (result.isPresent()) {
- matchEntryList.addAll(result.get());
- }
+ LAYER4_PROCESSOR.process(layer4Match, converterExecutor).ifPresent(matchEntryList::addAll);
}
private static void inPortMatch(final List<MatchEntry> matchEntryList, final NodeConnectorId inPort) {
Optional<GeneralExtensionListGrouping> extensionListOpt =
ExtensionResolvers.getMatchExtensionResolver().getExtension(source);
if (extensionListOpt.isPresent()) {
- for (ExtensionList extensionItem : extensionListOpt.get().nonnullExtensionList().values()) {
+ for (ExtensionList extensionItem : extensionListOpt.orElseThrow().nonnullExtensionList().values()) {
// TODO: get real version
ConverterExtensionKey<? extends ExtensionKey> key =
new ConverterExtensionKey<>(extensionItem.getExtensionKey(), OFConstants.OFP_VERSION_1_3);
if (convertor == null) {
throw new IllegalStateException("No converter found for key: " + key.toString());
}
- MatchEntry ofMatch = convertor.convert(extensionItem.getExtension());
- result.add(ofMatch);
+ result.add(convertor.convert(extensionItem.getExtension()));
}
}
public static <F, T> void inject(final Optional<F> source, final T target, final Uint8 version) {
F sourceResult;
if (source.isPresent()) {
- sourceResult = source.get();
+ sourceResult = source.orElseThrow();
} else if (OFConstants.OFP_VERSION_1_0.equals(version)) {
sourceResult = (F) MatchV10Convertor.defaultResult();
} else {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.util.Collection;
-import java.util.Collections;
import java.util.List;
import java.util.Optional;
+import java.util.Set;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.junit.MockitoJUnitRunner;
.registerConvertor(OFConstants.OFP_VERSION_1_3, new Convertor<Action, String, VersionConvertorData>() {
@Override
public Collection<Class<?>> getTypes() {
- return Collections.singleton(Action.class);
+ return Set.of(Action.class);
}
@Override
- public String convert(Action source, VersionConvertorData data) {
+ public String convert(final Action source, final VersionConvertorData data) {
return null;
}
});
.registerConvertor(OFConstants.OFP_VERSION_1_3, new Convertor<Action, String, VersionConvertorData>() {
@Override
public Collection<Class<?>> getTypes() {
- return Collections.singleton(Action.class);
+ return Set.of(Action.class);
}
@Override
- public String convert(Action source, VersionConvertorData data) {
+ public String convert(final Action source, final VersionConvertorData data) {
return String.valueOf(source) + String.valueOf(data);
}
});
final Action source = new ActionBuilder().setOrder(0).build();
final VersionConvertorData data = new VersionConvertorData(OFConstants.OFP_VERSION_1_3);
final String expectedResult = String.valueOf(source) + String.valueOf(data);
- final Optional<String> result = convertorManager.convert(source, data);
-
- assertTrue("Failed to convert action to string", result.isPresent());
- assertEquals("Result and expected result do not match", result.get(), expectedResult);
+ assertEquals(Optional.of(expectedResult), convertorManager.convert(source, data));
}
/**
new Convertor<List<Action>, String, VersionConvertorData>() {
@Override
public Collection<Class<?>> getTypes() {
- return Collections.singleton(Action.class);
+ return Set.of(Action.class);
}
@Override
- public String convert(List<Action> source, VersionConvertorData data) {
+ public String convert(final List<Action> source, final VersionConvertorData data) {
return String.valueOf(source) + String.valueOf(data);
}
});
- final List<Action> source = Collections.singletonList(new ActionBuilder().setOrder(0).build());
+ final List<Action> source = List.of(new ActionBuilder().setOrder(0).build());
final VersionConvertorData data = new VersionConvertorData(OFConstants.OFP_VERSION_1_3);
final String expectedResult = String.valueOf(source) + String.valueOf(data);
- final Optional<String> result = convertorManager.convert(source, data);
-
- assertTrue("Failed to convert action to string", result.isPresent());
- assertEquals("Result and expected result do not match", result.get(), expectedResult);
+ assertEquals(Optional.of(expectedResult), convertorManager.convert(source, data));
}
}
private GroupModInputBuilder convert(final Group group, final VersionDatapathIdConvertorData data) {
final Optional<GroupModInputBuilder> outAddGroupInputOptional = convertorManager.convert(group, data);
assertTrue("Group convertor not found", outAddGroupInputOptional.isPresent());
- return outAddGroupInputOptional.get();
+ return outAddGroupInputOptional.orElseThrow();
}
}
*/
@Test
public void testEmptyGroupStats() {
- List<GroupStats> groupStats = new ArrayList<>();
-
- Optional<List<org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.reply
- .GroupStats>> salGroupStats = convertorManager.convert(groupStats,
- new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
-
- Assert.assertFalse("Group stats response should be not present", salGroupStats.isPresent());
+ Assert.assertEquals(Optional.empty(), convertorManager.convert(List.of(),
+ new VersionConvertorData(OFConstants.OFP_VERSION_1_3)));
}
/**
new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
Assert.assertTrue("Group stats response convertor not found", salGroupStatsOptional.isPresent());
List<org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.reply
- .GroupStats> salGroupStats = salGroupStatsOptional.get();
+ .GroupStats> salGroupStats = salGroupStatsOptional.orElseThrow();
Assert.assertEquals("Wrong group stats size", 1, salGroupStats.size());
org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.reply
new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
Assert.assertTrue("Group stats response convertor not found", salGroupStatsOptional.isPresent());
List<org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.reply
- .GroupStats> salGroupStats = salGroupStatsOptional.get();
+ .GroupStats> salGroupStats = salGroupStatsOptional.orElseThrow();
Assert.assertEquals("Wrong group stats size", 2, salGroupStats.size());
org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.reply
new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
Assert.assertTrue("Group stats response convertor not found", salGroupStatsOptional.isPresent());
List<org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.reply
- .GroupStats> salGroupStats = salGroupStatsOptional.get();
+ .GroupStats> salGroupStats = salGroupStatsOptional.orElseThrow();
Assert.assertEquals("Wrong group stats size", 1, salGroupStats.size());
org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.reply
private List<FlowModInputBuilder> convert(final Flow flow, final VersionDatapathIdConvertorData data) {
Optional<List<FlowModInputBuilder>> flowModOptional = convertorManager.convert(flow, data);
assertTrue("Flow convertor not found", flowModOptional.isPresent());
- return flowModOptional.get();
+ return flowModOptional.orElseThrow();
}
private static Action createAction(
assertEquals(PRESET_COUNT, instructions.getInstruction().size());
}
- private Instructions convert(List<Instruction> instructionsList, VersionConvertorData data) {
+ private Instructions convert(final List<Instruction> instructionsList, final VersionConvertorData data) {
Optional<Instructions> instructionsOptional = convertorManager.convert(instructionsList, data);
assertTrue("Flow instruction response convertor not found", instructionsOptional.isPresent());
- return instructionsOptional.get();
+ return instructionsOptional.orElseThrow();
}
private interface MockActionBase extends ActionBase {
Optional<List<MatchEntry>> entriesOptional =
converterManager.convert(match, new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
- List<MatchEntry> entries = entriesOptional.get();
+ List<MatchEntry> entries = entriesOptional.orElseThrow();
assertEquals("Wrong entries size", 24, entries.size());
MatchEntry entry = entries.get(0);
checkEntryHeader(entry, InPort.VALUE, false);
Optional<List<MatchEntry>> entriesOptional = converterManager.convert(match,
new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
- List<MatchEntry> entries = entriesOptional.get();
+ List<MatchEntry> entries = entriesOptional.orElseThrow();
assertEquals("Wrong entries size", 2, entries.size());
MatchEntry entry = entries.get(0);
Optional<List<MatchEntry>> entriesOptional = converterManager.convert(match,
new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
- List<MatchEntry> entries = entriesOptional.get();
+ List<MatchEntry> entries = entriesOptional.orElseThrow();
assertEquals("Wrong entries size", 2, entries.size());
MatchEntry entry = entries.get(0);
Optional<List<MatchEntry>> entriesOptional =
converterManager.convert(match, new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
- List<MatchEntry> entries = entriesOptional.get();
+ List<MatchEntry> entries = entriesOptional.orElseThrow();
assertEquals("Wrong entries size", 2, entries.size());
MatchEntry entry = entries.get(0);
checkEntryHeader(entry, UdpSrc.VALUE, false);
Optional<List<MatchEntry>> entriesOptional =
converterManager.convert(match, new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
- List<MatchEntry> entries = entriesOptional.get();
+ List<MatchEntry> entries = entriesOptional.orElseThrow();
assertEquals("Wrong entries size", 2, entries.size());
MatchEntry entry = entries.get(0);
checkEntryHeader(entry, Ipv4Src.VALUE, false);
Optional<List<MatchEntry>> entriesOptional =
converterManager.convert(match, new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
- List<MatchEntry> entries = entriesOptional.get();
+ List<MatchEntry> entries = entriesOptional.orElseThrow();
assertEquals("Wrong entries size", 2, entries.size());
MatchEntry entry = entries.get(0);
checkEntryHeader(entry, SctpSrc.VALUE, false);
Optional<List<MatchEntry>> entriesOptional =
converterManager.convert(match, new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
- List<MatchEntry> entries = entriesOptional.get();
+ List<MatchEntry> entries = entriesOptional.orElseThrow();
assertEquals("Wrong entries size", 5, entries.size());
MatchEntry entry = entries.get(0);
checkEntryHeader(entry, ArpOp.VALUE, false);
Optional<List<MatchEntry>> entriesOptional =
converterManager.convert(match, new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
- List<MatchEntry> entries = entriesOptional.get();
+ List<MatchEntry> entries = entriesOptional.orElseThrow();
assertEquals("Wrong entries size", 4, entries.size());
MatchEntry entry = entries.get(0);
entry = entries.get(0);
Optional<List<MatchEntry>> entriesOptional =
converterManager.convert(match, new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
- List<MatchEntry> entries = entriesOptional.get();
+ List<MatchEntry> entries = entriesOptional.orElseThrow();
assertEquals("Wrong entries size", 7, entries.size());
MatchEntry entry = entries.get(0);
/* Due to conversion ambiguities, we always get "has mask" because
Optional<List<MatchEntry>> entriesOptional =
converterManager.convert(match, new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
- List<MatchEntry> entries = entriesOptional.get();
+ List<MatchEntry> entries = entriesOptional.orElseThrow();
assertEquals("Wrong entries size", 2, entries.size());
MatchEntry entry = entries.get(0);
checkEntryHeader(entry, Ipv6Src.VALUE, true);
Optional<List<MatchEntry>> entriesOptional =
converterManager.convert(match, new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
- List<MatchEntry> entries = entriesOptional.get();
+ List<MatchEntry> entries = entriesOptional.orElseThrow();
assertEquals("Wrong entries size", 1, entries.size());
MatchEntry entry = entries.get(0);
checkEntryHeader(entry, Ipv6Exthdr.VALUE, true);
Optional<List<MatchEntry>> entriesOptional =
converterManager.convert(match, new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
- List<MatchEntry> entries = entriesOptional.get();
+ List<MatchEntry> entries = entriesOptional.orElseThrow();
assertEquals("Wrong entries size", 8, entries.size());
MatchEntry entry = entries.get(0);
checkEntryHeader(entry, Metadata.VALUE, true);
Optional<List<MatchEntry>> entriesOptional = converterManager.convert(match,
new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
- List<MatchEntry> entries = entriesOptional.get();
+ List<MatchEntry> entries = entriesOptional.orElseThrow();
assertEquals("Wrong entries size", 2, entries.size());
MatchEntry entry = entries.get(0);
Optional<List<MatchEntry>> entriesOptional =
converterManager.convert(match, new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
- List<MatchEntry> entries = entriesOptional.get();
+ List<MatchEntry> entries = entriesOptional.orElseThrow();
assertEquals("Wrong entries size", 1, entries.size());
MatchEntry entry = entries.get(0);
checkEntryHeader(entry, PacketType.VALUE, false);
Optional<MatchV10> matchV10Optional = converterManager.convert(createL4UdpMatch().build(),
new VersionConvertorData(OFConstants.OFP_VERSION_1_0));
- MatchV10 matchV10 = matchV10Optional.get();
+ MatchV10 matchV10 = matchV10Optional.orElseThrow();
assertEquals(ZERO_MAC, matchV10.getDlDst());
assertEquals(FF_MAC, matchV10.getDlSrc());
matchV10Optional = converterManager.convert(createL4TcpMatch().build(),
new VersionConvertorData(OFConstants.OFP_VERSION_1_0));
- matchV10 = matchV10Optional.get();
+ matchV10 = matchV10Optional.orElseThrow();
assertEquals(DEFAULT_PORT.getValue(), matchV10.getTpSrc());
assertEquals(DEFAULT_PORT.getValue(), matchV10.getTpDst());
matchV10Optional = converterManager.convert(createVlanTcpMatch().build(),
new VersionConvertorData(OFConstants.OFP_VERSION_1_0));
- matchV10 = matchV10Optional.get();
+ matchV10 = matchV10Optional.orElseThrow();
assertEquals(DEFAULT_VLAN_ID.getValue(), matchV10.getDlVlan());
}
Match match = matchBuilder.build();
Optional<MatchV10> matchV10Optional = converterManager.convert(match,
new VersionConvertorData(OFConstants.OFP_VERSION_1_0));
- MatchV10 matchV10 = matchV10Optional.get();
+ MatchV10 matchV10 = matchV10Optional.orElseThrow();
assertEquals(ZERO_MAC, matchV10.getDlDst());
assertEquals(FF_MAC, matchV10.getDlSrc());
match = matchBuilder.setIcmpv4Match(icmpv4MatchBuilder.build()).build();
matchV10Optional = converterManager.convert(match,
new VersionConvertorData(OFConstants.OFP_VERSION_1_0));
- matchV10 = matchV10Optional.get();
+ matchV10 = matchV10Optional.orElseThrow();
assertEquals(ZERO_MAC, matchV10.getDlDst());
assertEquals(FF_MAC, matchV10.getDlSrc());
assertEquals(0, matchV10.getDlType().intValue());
match = matchBuilder.setIcmpv4Match(icmpv4MatchBuilder.build()).build();
matchV10Optional = converterManager.convert(match,
new VersionConvertorData(OFConstants.OFP_VERSION_1_0));
- matchV10 = matchV10Optional.get();
+ matchV10 = matchV10Optional.orElseThrow();
assertEquals(ZERO_MAC, matchV10.getDlDst());
assertEquals(FF_MAC, matchV10.getDlSrc());
assertEquals(Uint16.ZERO, matchV10.getDlType());
wc = new FlowWildcardsV10(false, false, false, true, true, false, false, false, wcTpDst, wcTpSrc);
match = matchBuilder.setIcmpv4Match(icmpv4MatchBuilder.build()).build();
matchV10Optional = converterManager.convert(match, new VersionConvertorData(OFConstants.OFP_VERSION_1_0));
- matchV10 = matchV10Optional.get();
+ matchV10 = matchV10Optional.orElseThrow();
assertEquals(ZERO_MAC, matchV10.getDlDst());
assertEquals(FF_MAC, matchV10.getDlSrc());
assertEquals(Uint16.ZERO, matchV10.getDlType());
*/
package org.opendaylight.openflowplugin.test;
-import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
// Hidden on purpose
}
- public static <T extends DataObject> T getDataObject(ReadTransaction readOnlyTransaction,
- InstanceIdentifier<T> identifier) {
- Optional<T> optionalData = null;
+ public static <T extends DataObject> T getDataObject(final ReadTransaction readOnlyTransaction,
+ final InstanceIdentifier<T> identifier) {
try {
- optionalData = readOnlyTransaction.read(LogicalDatastoreType.OPERATIONAL, identifier).get();
- if (optionalData.isPresent()) {
- return optionalData.get();
- }
+ return readOnlyTransaction.read(LogicalDatastoreType.OPERATIONAL, identifier).get().orElse(null);
} catch (ExecutionException | InterruptedException e) {
LOG.error("Read transaction for identifier {} failed.", identifier, e);
+ return null;
}
- return null;
}
}
Code Review / openflowplugin.git / commitdiff