<artifactId>javax.annotation-api</artifactId>
<optional>true</optional>
</dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- <version>3.0.2</version>
- <optional>true</optional>
- </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-api</artifactId>
import java.util.Collections;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
}
@Override
- public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<FlowCapableNode>> changes) {
+ public void onDataTreeChanged(@NonNull final Collection<DataTreeModification<FlowCapableNode>> changes) {
Preconditions.checkNotNull(changes, "Changes may not be null!");
for (DataTreeModification<FlowCapableNode> change : changes) {
}
@Override
- public void onBecomeOwner(@Nonnull final DeviceInfo deviceInfo) {
+ public void onBecomeOwner(@NonNull final DeviceInfo deviceInfo) {
LOG.debug("Mastership role notification received for device : {}", deviceInfo.getDatapathId());
DeviceMastership membership = deviceMasterships.computeIfAbsent(deviceInfo.getNodeId(),
device -> new DeviceMastership(deviceInfo.getNodeId()));
}
@Override
- public void onLoseOwnership(@Nonnull final DeviceInfo deviceInfo) {
+ public void onLoseOwnership(@NonNull final DeviceInfo deviceInfo) {
final DeviceMastership mastership = deviceMasterships.remove(deviceInfo.getNodeId());
if (mastership != null) {
mastership.deregisterReconciliationRpc();
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicLong;
-import javax.annotation.Nonnull;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
}
@Override
- public void onPropertyChanged(@Nonnull final String propertyName, @Nonnull final String propertyValue) {
+ public void onPropertyChanged(@NonNull final String propertyName, @NonNull final String propertyValue) {
final ForwardingRulesProperty forwardingRulesProperty = ForwardingRulesProperty.forValue(propertyName);
if (forwardingRulesProperty != null) {
switch (forwardingRulesProperty) {
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.concurrent.Callable;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
/**
* JobEntry is the entity built per job submitted by the application and
import com.google.common.base.MoreObjects;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
/**
* A queue which holds job entries and the current running job.
<artifactId>javax.annotation-api</artifactId>
<optional>true</optional>
</dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- <version>3.0.2</version>
- <optional>true</optional>
- </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
package org.opendaylight.openflowplugin.applications.frsync;
import java.util.concurrent.Semaphore;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
/**
* Key based semaphore provider.
* @param key semaphore identifier
* @return new or existing semaphore for given key, for one key there is always only one semaphore available
*/
- Semaphore summonGuard(@Nonnull K key);
+ Semaphore summonGuard(@NonNull K key);
/**
* Get guard and lock for key.
* @param key for which guard should be created and acquired
* @return semaphore guard
*/
- Semaphore summonGuardAndAcquire(@Nonnull K key);
+ Semaphore summonGuardAndAcquire(@NonNull K key);
/**
* Unlock and release guard.
package org.opendaylight.openflowplugin.applications.frsync.dao;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
}
@Override
- public Optional<FlowCapableNode> loadByNodeId(@Nonnull NodeId nodeId) {
+ public Optional<FlowCapableNode> loadByNodeId(@NonNull NodeId nodeId) {
final Optional<FlowCapableNode> node = snapshotDao.loadByNodeId(nodeId);
if (node.isPresent()) {
package org.opendaylight.openflowplugin.applications.frsync.dao;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
* Data access object for {@link FlowCapableNode}.
*/
public interface FlowCapableNodeDao {
- Optional<FlowCapableNode> loadByNodeId(@Nonnull NodeId nodeId);
+ Optional<FlowCapableNode> loadByNodeId(@NonNull NodeId nodeId);
}
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
}
@Override
- public Optional<FlowCapableNode> loadByNodeId(@Nonnull NodeId nodeId) {
+ public Optional<FlowCapableNode> loadByNodeId(@NonNull NodeId nodeId) {
try (ReadTransaction roTx = dataBroker.newReadOnlyTransaction()) {
final InstanceIdentifier<FlowCapableNode> path =
NODES_IID.child(Node.class, new NodeKey(nodeId)).augmentation(FlowCapableNode.class);
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
private final ConcurrentHashMap<String, FlowCapableNode> cache = new ConcurrentHashMap<>();
- public void updateCache(@Nonnull NodeId nodeId, Optional<FlowCapableNode> dataAfter) {
+ public void updateCache(@NonNull NodeId nodeId, Optional<FlowCapableNode> dataAfter) {
if (dataAfter.isPresent()) {
cache.put(nodeId.getValue(), dataAfter.get());
} else {
}
@Override
- public Optional<FlowCapableNode> loadByNodeId(@Nonnull NodeId nodeId) {
+ public Optional<FlowCapableNode> loadByNodeId(@NonNull NodeId nodeId) {
final FlowCapableNode node = cache.get(nodeId.getValue());
return Optional.ofNullable(node);
}
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-import javax.annotation.Nonnull;
+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;
private static final Logger LOG = LoggerFactory.getLogger(AbstractFrmSyncListener.class);
@Override
- public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<T>> modifications) {
+ public void onDataTreeChanged(@NonNull final Collection<DataTreeModification<T>> modifications) {
for (DataTreeModification<T> modification : modifications) {
final NodeId nodeId = PathUtil.digNodeId(modification.getRootPath().getRootIdentifier());
if (LOG.isTraceEnabled()) {
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collection;
import java.util.Optional;
-import javax.annotation.Nonnull;
+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(@NonNull final Collection<DataTreeModification<FlowCapableNode>> modifications) {
super.onDataTreeChanged(modifications);
}
import java.util.Date;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+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(@NonNull final Collection<DataTreeModification<Node>> modifications) {
super.onDataTreeChanged(modifications);
}
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
throw new IllegalAccessError("non instantiable util class");
}
- @Nonnull
+ @NonNull
public static Map<Uint8, Table> wrapTablesToMap(@Nullable final List<Table> tables) {
final Map<Uint8, Table> tableMap;
return tableMap;
}
- @Nonnull
+ @NonNull
public static Map<FlowDescriptor, Flow> wrapFlowsToMap(@Nullable final List<Flow> flows) {
final Map<FlowDescriptor, Flow> flowMap;
return flowConfigMap.get(new FlowDescriptor(flow));
}
- @Nonnull
+ @NonNull
public static Map<MeterId, Meter> wrapMetersToMap(@Nullable final List<Meter> meters) {
final Map<MeterId, Meter> meterMap;
return meterMap;
}
- @Nonnull
+ @NonNull
public static Map<Uint32, Group> wrapGroupsToMap(@Nullable final List<Group> groups) {
final Map<Uint32, Group> groupMap;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import java.util.concurrent.Semaphore;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowplugin.applications.frsync.SemaphoreKeeper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Override
- public Semaphore summonGuard(@Nonnull final K key) {
+ public Semaphore summonGuard(@NonNull final K key) {
return semaphoreCache.getUnchecked(key);
}
@Override
- public Semaphore summonGuardAndAcquire(@Nonnull final K key) {
+ public Semaphore summonGuardAndAcquire(@NonNull final K key) {
final Semaphore guard = Preconditions.checkNotNull(summonGuard(key), "Guard not available for " + key);
try {
guard.acquire();
<artifactId>javax.annotation-api</artifactId>
<optional>true</optional>
</dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- <version>3.0.2</version>
- <optional>true</optional>
- </dependency>
<dependency>
<groupId>org.opendaylight.openflowplugin</groupId>
<artifactId>openflowplugin-api</artifactId>
import com.google.common.base.Strings;
import java.math.BigInteger;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.libraries.liblldp.EtherTypes;
import org.opendaylight.openflowplugin.libraries.liblldp.Ethernet;
import org.opendaylight.openflowplugin.libraries.liblldp.HexEncode;
private LLDPUtil() {
}
- @Nonnull
+ @NonNull
static byte[] buildLldpFrame(final NodeId nodeId, final NodeConnectorId nodeConnectorId, final MacAddress src,
final Uint32 outPortNo, final MacAddress destinationAddress)
throws PacketException {
return ethPkt.serialize();
}
- @Nonnull
+ @NonNull
static byte[] buildLldpFrame(final NodeId nodeId, final NodeConnectorId nodeConnectorId,
final MacAddress srcMacAddress, final Uint32 outputPortNo) throws PacketException {
return buildLldpFrame(nodeId, nodeConnectorId, srcMacAddress, outputPortNo, null);
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
}
@Override
- public void onDataTreeChanged(@Nonnull Collection<DataTreeModification<T>> modifications) {
+ public void onDataTreeChanged(@NonNull Collection<DataTreeModification<T>> modifications) {
for (DataTreeModification modification : modifications) {
LOG.trace("Node connectors in inventory changed -> {}", modification.getRootNode().getModificationType());
switch (modification.getRootNode().getModificationType()) {
<artifactId>blueprint-maven-plugin-annotation</artifactId>
<optional>true</optional>
</dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- <version>3.0.2</version>
- <optional>true</optional>
- </dependency>
</dependencies>
<build>
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.apache.aries.blueprint.annotation.service.Service;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeException;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeServiceManager;
}
@Override
- public ListenableFuture<ResultState> onDevicePrepared(@Nonnull DeviceInfo node) {
+ public ListenableFuture<ResultState> onDevicePrepared(@NonNull DeviceInfo node) {
LOG.debug("Triggering reconciliation for node : {}", node.getNodeId());
return futureMap.computeIfAbsent(node, value -> reconcileNode(node));
}
@Override
- public ListenableFuture<Void> onDeviceDisconnected(@Nonnull DeviceInfo node) {
+ public ListenableFuture<Void> onDeviceDisconnected(@NonNull DeviceInfo node) {
LOG.info("Stopping reconciliation for node {}", node.getNodeId());
if (futureMap.containsKey(node)) {
return cancelNodeReconciliation(node);
<artifactId>javax.annotation-api</artifactId>
<optional>true</optional>
</dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- <version>3.0.2</version>
- <optional>true</optional>
- </dependency>
</dependencies>
</project>
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
private ShellUtil() {
}
- @Nonnull
+ @NonNull
public static List<OFNode> getAllNodes(final DataBroker broker) {
List<Node> nodes = null;
InstanceIdentifier<Nodes> path = InstanceIdentifier.builder(Nodes.class).build();
<groupId>org.apache.aries.blueprint</groupId>
<artifactId>blueprint-maven-plugin-annotation</artifactId>
<optional>true</optional>
- </dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- <version>3.0.2</version>
- <optional>true</optional>
</dependency>
<dependency>
<groupId>org.opendaylight.openflowplugin</groupId>
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ConcurrentHashMap;
-import javax.annotation.Nonnull;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
}
@Override
- public void onPropertyChanged(@Nonnull final String propertyName, @Nonnull final String propertyValue) {
+ public void onPropertyChanged(@NonNull final String propertyName, @NonNull final String propertyValue) {
final TopologyLLDPDiscoveryProperty lldpDiscoveryProperty = TopologyLLDPDiscoveryProperty.forValue(
propertyName);
if (lldpDiscoveryProperty != null) {
<artifactId>javax.annotation-api</artifactId>
<optional>true</optional>
</dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- <version>3.0.2</version>
- <optional>true</optional>
- </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>openflowplugin-extension-api</artifactId>
import com.google.common.math.LongMath;
import java.math.RoundingMode;
import java.util.Collections;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowjava.nx.codec.match.NiciraMatchCodecs;
import org.opendaylight.openflowplugin.extension.api.ConvertorActionFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorActionToOFJava;
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
</dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- <version>3.0.2</version>
- <optional>true</optional>
- </dependency>
</dependencies>
<build>
package org.opendaylight.openflowplugin.libraries.liblldp;
import java.util.Arrays;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* when the startOffset and numBits parameters are not congruent
* with the data buffer size
*/
- @Nonnull
+ @NonNull
public static byte[] getBits(final byte[] data, final int startOffset, final int numBits) throws BufferException {
int startByteOffset;
int extranumBits = numBits % NetUtils.NUM_BITS_IN_A_BYTE;
<version>${infrautils.version}</version>
<scope>compile</scope>
</dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- <version>3.0.2</version>
- <optional>true</optional>
- </dependency>
</dependencies>
</project>
package org.opendaylight.openflowjava.protocol.api.connection;
import com.google.common.base.Preconditions;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.Error;
/**
private static final long serialVersionUID = 1L;
private final transient Error error;
- public DeviceRequestFailedException(final String message, @Nonnull final Error error) {
+ public DeviceRequestFailedException(final String message, @NonNull final Error error) {
super(message);
this.error = Preconditions.checkNotNull(error);
}
- public DeviceRequestFailedException(final String message, @Nonnull final Error error, final Throwable cause) {
+ public DeviceRequestFailedException(final String message, @NonNull final Error error, final Throwable cause) {
super(message, cause);
this.error = Preconditions.checkNotNull(error);
}
- @Nonnull public Error getError() {
+ @NonNull public Error getError() {
return error;
}
}
import com.google.common.annotations.Beta;
import com.google.common.util.concurrent.FutureCallback;
import java.util.function.Function;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
@Beta
* @throws IllegalArgumentException if the slot is already committed or was never reserved.
*/
void commitEntry(
- @Nonnull Long xid,
+ @NonNull Long xid,
@Nullable OfHeader message,
@Nullable FutureCallback<OfHeader> callback);
* @throws IllegalArgumentException if the slot is already committed or was never reserved.
*/
void commitEntry(
- @Nonnull Long xid,
+ @NonNull Long xid,
@Nullable OfHeader message,
@Nullable FutureCallback<OfHeader> callback,
@Nullable Function<OfHeader, Boolean> isComplete);
package org.opendaylight.openflowjava.protocol.api.connection;
import com.google.common.annotations.Beta;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.BarrierInput;
/**
* @param xid XID for the barrier message
* @return New barrier message.
*/
- @Nonnull BarrierInput createBarrierRequest(@Nonnull Long xid);
+ @NonNull BarrierInput createBarrierRequest(@NonNull Long xid);
/**
* Invoked whenever the underlying queue is refreshed. Implementations should
<!-- Explicitly bring in the linux classifier, test may fail on 32-bit linux -->
<classifier>linux-x86_64</classifier>
</dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- <version>3.0.2</version>
- <optional>true</optional>
- </dependency>
</dependencies>
</project>
import com.google.common.util.concurrent.MoreExecutors;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.epoll.Epoll;
-import org.checkerframework.checker.nullness.qual.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.infrautils.diagstatus.ServiceState;
import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionConfiguration;
import java.util.concurrent.Future;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.TimeUnit;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.BarrierInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.BarrierOutput;
protected Cache<RpcResponseKey, ResponseExpectedRpcListener<?>> responseCache;
- AbstractConnectionAdapter(@Nonnull final Channel channel, @Nullable final InetSocketAddress address,
+ AbstractConnectionAdapter(@NonNull final Channel channel, @Nullable final InetSocketAddress address,
@Nullable final int channelOutboundQueueSize) {
this.channel = Preconditions.checkNotNull(channel);
this.address = address;
import java.net.InetSocketAddress;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueueHandler;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.EchoReplyInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.EchoReplyInputBuilder;
* which is send to OFEncoder for serialization. Correct wrapper is
* selected by communication pipeline.
*/
- protected Object makeMessageListenerWrapper(@Nonnull final OfHeader msg) {
+ protected Object makeMessageListenerWrapper(@NonNull final OfHeader msg) {
Preconditions.checkArgument(msg != null);
if (address == null) {
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.atomic.AtomicLongFieldUpdater;
-import javax.annotation.Nonnull;
-import javax.annotation.concurrent.GuardedBy;
+import org.checkerframework.checker.lock.qual.GuardedBy;
+import org.checkerframework.checker.lock.qual.Holding;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueue;
import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueueException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
commitEntry(xid, message, callback, OutboundQueueEntry.DEFAULT_IS_COMPLETE);
}
- @GuardedBy("unflushedSegments")
+ @Holding("unflushedSegments")
protected void ensureSegment(final StackedSegment first, final int offset) {
final int segmentOffset = offset / StackedSegment.SEGMENT_SIZE;
LOG.debug("Queue {} slow offset {} maps to {} segments {}", this, offset, segmentOffset,
* @param now time stamp
* @return Number of entries written out
*/
- int writeEntries(@Nonnull final Channel channel, final long now) {
+ int writeEntries(@NonNull final Channel channel, final long now) {
// Local cache
StackedSegment segment = firstSegment;
int entries = 0;
import com.google.common.util.concurrent.FutureCallback;
import io.netty.channel.Channel;
import java.util.function.Function;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FlowModInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
import org.slf4j.Logger;
}
@Override
- int writeEntries(@Nonnull final Channel channel, final long now) {
+ int writeEntries(@NonNull final Channel channel, final long now) {
// Local cache
StackedSegment segment = firstSegment;
int entries = 0;
package org.opendaylight.openflowjava.protocol.impl.util;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* Abstract factory class to support OF protocol version assigning and reading.
*
* @param newVersion OpenFlow protocol version
*/
- public void assignVersion(@Nonnull final Short newVersion) {
+ public void assignVersion(@NonNull final Short newVersion) {
if (this.version == null) {
this.version = newVersion;
} else {
package org.opendaylight.openflowjava.protocol.impl.core.connection;
import com.google.common.util.concurrent.FutureCallback;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-eos-binding-api</artifactId>
</dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- <version>3.0.2</version>
- <optional>true</optional>
- </dependency>
</dependencies>
</project>
*/
package org.opendaylight.openflowplugin.api.openflow;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.lifecycle.ContextChainMastershipWatcher;
* Registers mastership change listener to context.
* @param contextChainMastershipWatcher mastership change listener
*/
- void registerMastershipWatcher(@Nonnull ContextChainMastershipWatcher contextChainMastershipWatcher);
+ void registerMastershipWatcher(@NonNull ContextChainMastershipWatcher contextChainMastershipWatcher);
@Override
void close();
package org.opendaylight.openflowplugin.api.openflow.configuration;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* Listens for changes in OpenFlowPlugin configuration.
* @param propertyName the property name
* @param propertyValue the property value
*/
- void onPropertyChanged(@Nonnull String propertyName, @Nonnull String propertyValue);
+ void onPropertyChanged(@NonNull String propertyName, @NonNull String propertyValue);
}
import java.util.Map;
import java.util.function.Function;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* Manages OpenFlowPlugin configuration.
*
* @param properties properties
*/
- void update(@Nonnull Map<String, String> properties);
+ void update(@NonNull Map<String, String> properties);
/**
* Register listener for configuration changes.
* @param listener the listener
* @return the auto closeable listener registration
*/
- @Nonnull
- AutoCloseable registerListener(@Nonnull ConfigurationListener listener);
+ @NonNull
+ AutoCloseable registerListener(@NonNull ConfigurationListener listener);
/**
* Get single property from configuration service.
* @param transformer property type transformer
* @return property property
*/
- @Nonnull
- <T> T getProperty(@Nonnull String key, @Nonnull Function<String, T> transformer);
+ @NonNull
+ <T> T getProperty(@NonNull String key, @NonNull Function<String, T> transformer);
}
package org.opendaylight.openflowplugin.api.openflow.device;
import com.google.common.util.concurrent.ListenableFuture;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.OFPManager;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.lifecycle.ContextChainHolder;
*/
void initialize();
- ListenableFuture<?> removeDeviceFromOperationalDS(@Nonnull KeyedInstanceIdentifier<Node, NodeKey> ii);
+ ListenableFuture<?> removeDeviceFromOperationalDS(@NonNull KeyedInstanceIdentifier<Node, NodeKey> ii);
- DeviceContext createContext(@Nonnull ConnectionContext connectionContext);
+ DeviceContext createContext(@NonNull ConnectionContext connectionContext);
void sendNodeAddedNotification(
- @Nonnull KeyedInstanceIdentifier<Node, NodeKey> instanceIdentifier);
+ @NonNull KeyedInstanceIdentifier<Node, NodeKey> instanceIdentifier);
void sendNodeRemovedNotification(
- @Nonnull KeyedInstanceIdentifier<Node, NodeKey> instanceIdentifier);
+ @NonNull KeyedInstanceIdentifier<Node, NodeKey> instanceIdentifier);
- void setContextChainHolder(@Nonnull ContextChainHolder contextChainHolder);
+ void setContextChainHolder(@NonNull ContextChainHolder contextChainHolder);
}
*/
package org.opendaylight.openflowplugin.api.openflow.device;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
/**
* Request context handles all requests on device. Number of requests is limited by request quota. When this quota is
*/
package org.opendaylight.openflowplugin.api.openflow.device;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
/**
* Request context stack.
*/
package org.opendaylight.openflowplugin.api.openflow.device.handlers;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.EventIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
* @param reqMore request more replies
* @param eventIdentifier event identifier
*/
- void addMultipartMsg(@Nonnull T reply, boolean reqMore, @Nullable EventIdentifier eventIdentifier);
+ void addMultipartMsg(@NonNull T reply, boolean reqMore, @Nullable EventIdentifier eventIdentifier);
/**
* Null response could be a valid end multipart collecting event for barrier response scenario.
*/
package org.opendaylight.openflowplugin.api.openflow.lifecycle;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.openflowplugin.api.openflow.OFPContext;
* Add context to the chain, if reference already exist ignore it.
* @param context child of OFPContext
*/
- <T extends OFPContext> void addContext(@Nonnull T context);
+ <T extends OFPContext> void addContext(@NonNull T context);
@Override
void close();
* @return true if everything done fine
* @see org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeService
*/
- boolean isMastered(@Nonnull ContextChainMastershipState mastershipState,
+ boolean isMastered(@NonNull ContextChainMastershipState mastershipState,
boolean inReconciliationFrameworkStep);
/**
* @param connectionContext new connection to the device.
* @return false if primary connection is broken
*/
- boolean addAuxiliaryConnection(@Nonnull ConnectionContext connectionContext);
+ boolean addAuxiliaryConnection(@NonNull ConnectionContext connectionContext);
/**
* Check if connection is auxiliary and if yes then continue working.
* @param connectionContext connection to the device
* @return false if this is primary connection
*/
- boolean auxiliaryConnectionDropped(@Nonnull ConnectionContext connectionContext);
+ boolean auxiliaryConnectionDropped(@NonNull ConnectionContext connectionContext);
/**
* This method registers device removed handler what will be executed when device should be removed.
* @param deviceRemovedHandler device removed handler
*/
- void registerDeviceRemovedHandler(@Nonnull DeviceRemovedHandler deviceRemovedHandler);
+ void registerDeviceRemovedHandler(@NonNull DeviceRemovedHandler deviceRemovedHandler);
}
\ No newline at end of file
*/
package org.opendaylight.openflowplugin.api.openflow.lifecycle;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
/**
* @param deviceInfo connected switch identification
* @param mastershipState state
*/
- void onMasterRoleAcquired(DeviceInfo deviceInfo, @Nonnull ContextChainMastershipState mastershipState);
+ void onMasterRoleAcquired(DeviceInfo deviceInfo, @NonNull ContextChainMastershipState mastershipState);
/**
* Change to SLAVE role on device was successful.
package org.opendaylight.openflowplugin.api.openflow.lifecycle;
import com.google.common.util.concurrent.ListenableFuture;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.rf.state.rev170713.ResultState;
* </ul>
* @param deviceInfo connected switch identification
*/
- void becomeMaster(@Nonnull DeviceInfo deviceInfo);
+ void becomeMaster(@NonNull DeviceInfo deviceInfo);
/**
* Should be called when device is disconnected or going to be slaved.
* @param deviceInfo connected switch identification
*/
- void becomeSlaveOrDisconnect(@Nonnull DeviceInfo deviceInfo);
+ void becomeSlaveOrDisconnect(@NonNull DeviceInfo deviceInfo);
/**
* Should be called when device is being mastered as in {@link #becomeMaster(DeviceInfo)}.
* @param deviceInfo connected switch identification
* @return future to be able handle device after reconciliation
*/
- ListenableFuture<ResultState> becomeMasterBeforeSubmittedDS(@Nonnull DeviceInfo deviceInfo);
+ ListenableFuture<ResultState> becomeMasterBeforeSubmittedDS(@NonNull DeviceInfo deviceInfo);
/**
* Set the device mastership checker.
* @param masterChecker {@link MasterChecker}
*/
- void setMasterChecker(@Nonnull MasterChecker masterChecker);
+ void setMasterChecker(@NonNull MasterChecker masterChecker);
}
*/
package org.opendaylight.openflowplugin.api.openflow.mastership;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.lifecycle.OwnershipChangeListener;
* {@link OwnershipChangeListener#becomeMaster(DeviceInfo)}
* @param deviceInfo connected switch identification
*/
- void onBecomeOwner(@Nonnull DeviceInfo deviceInfo);
+ void onBecomeOwner(@NonNull DeviceInfo deviceInfo);
/**
* Event when device disconnected or become slave. This event is evoked by
* {@link OwnershipChangeListener#becomeSlaveOrDisconnect(DeviceInfo)}
* @param deviceInfo connected switch identification
*/
- void onLoseOwnership(@Nonnull DeviceInfo deviceInfo);
+ void onLoseOwnership(@NonNull DeviceInfo deviceInfo);
}
\ No newline at end of file
*/
package org.opendaylight.openflowplugin.api.openflow.mastership;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.lifecycle.OwnershipChangeListener;
/**
* @return registration
* @see ReconciliationFrameworkEvent
*/
- @Nonnull
- MastershipChangeRegistration register(@Nonnull MastershipChangeService service);
+ @NonNull
+ MastershipChangeRegistration register(@NonNull MastershipChangeService service);
/**
* Setter for reconciliation framework event listener. It can be registered only once.
* @throws MastershipChangeException if already reconciliation framework registered
*/
ReconciliationFrameworkRegistration reconciliationFrameworkRegistration(
- @Nonnull ReconciliationFrameworkEvent mastershipRFRegistration) throws MastershipChangeException;
+ @NonNull ReconciliationFrameworkEvent mastershipRFRegistration) throws MastershipChangeException;
@Override
void close();
package org.opendaylight.openflowplugin.api.openflow.mastership;
import com.google.common.util.concurrent.ListenableFuture;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.lifecycle.OwnershipChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.rf.state.rev170713.ResultState;
* @param deviceInfo connected switch identification
* @return result state if the device can continue with connecting or should be disconnected
*/
- ListenableFuture<ResultState> onDevicePrepared(@Nonnull DeviceInfo deviceInfo);
+ ListenableFuture<ResultState> onDevicePrepared(@NonNull DeviceInfo deviceInfo);
/**
* This event occurs after device is disconnected or being slaved.
* @return future
* @see MastershipChangeService
*/
- ListenableFuture<Void> onDeviceDisconnected(@Nonnull DeviceInfo deviceInfo);
+ ListenableFuture<Void> onDeviceDisconnected(@NonNull DeviceInfo deviceInfo);
}
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowplugin.api.openflow.registry.CommonDeviceRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
ListenableFuture<List<Optional<FlowCapableNode>>> fill();
- void storeDescriptor(@Nonnull FlowRegistryKey flowRegistryKey, @Nonnull FlowDescriptor flowDescriptor);
+ void storeDescriptor(@NonNull FlowRegistryKey flowRegistryKey, @NonNull FlowDescriptor flowDescriptor);
@Nullable
- FlowDescriptor retrieveDescriptor(@Nonnull FlowRegistryKey flowRegistryKey);
+ FlowDescriptor retrieveDescriptor(@NonNull FlowRegistryKey flowRegistryKey);
}
package org.opendaylight.openflowplugin.api.openflow.role;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.OFPManager;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
* @param deviceContext the device context
* @return the role context
*/
- RoleContext createContext(@Nonnull DeviceContext deviceContext);
+ RoleContext createContext(@NonNull DeviceContext deviceContext);
}
\ No newline at end of file
package org.opendaylight.openflowplugin.api.openflow.rpc;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.OFPManager;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
*/
public interface RpcManager extends OFPManager {
- RpcContext createContext(@Nonnull DeviceContext deviceContext);
+ RpcContext createContext(@NonNull DeviceContext deviceContext);
}
package org.opendaylight.openflowplugin.api.openflow.statistics;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.OFPManager;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
* Manages statistics contexts.
*/
public interface StatisticsManager extends OFPManager {
- StatisticsContext createContext(@Nonnull DeviceContext deviceContext,
+ StatisticsContext createContext(@NonNull DeviceContext deviceContext,
boolean useReconciliationFramework);
}
\ No newline at end of file
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-api</artifactId>
</dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- <version>3.0.2</version>
- <optional>true</optional>
- </dependency>
<dependency>
<groupId>org.slf4j</groupId>
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-import javax.annotation.Nonnull;
-import javax.annotation.concurrent.GuardedBy;
+import org.checkerframework.checker.lock.qual.GuardedBy;
+import org.checkerframework.checker.lock.qual.Holding;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.binding.api.Transaction;
@GuardedBy("txLock")
private TransactionChainManagerStatus transactionChainManagerStatus = TransactionChainManagerStatus.SLEEPING;
- public TransactionChainManager(@Nonnull final DataBroker dataBroker,
- @Nonnull final String deviceIdentifier) {
+ public TransactionChainManager(@NonNull final DataBroker dataBroker,
+ @NonNull final String deviceIdentifier) {
this.dataBroker = dataBroker;
this.nodeId = deviceIdentifier;
this.lastSubmittedFuture = CommitInfo.emptyFluentFuture();
}
- @GuardedBy("txLock")
+ @Holding("txLock")
private void createTxChain() {
TransactionChain txChainFactoryTemp = transactionChain;
transactionChain = dataBroker.createTransactionChain(TransactionChainManager.this);
}
@Override
- public void onFailure(@Nonnull final Throwable throwable) {
+ public void onFailure(@NonNull final Throwable throwable) {
closeTransactionChain();
}
}, MoreExecutors.directExecutor());
// NOOP
}
- @GuardedBy("txLock")
+ @Holding("txLock")
private void ensureTransaction() {
if (writeTx == null && TransactionChainManagerStatus.WORKING == transactionChainManagerStatus
&& transactionChain != null) {
<artifactId>javax.inject</artifactId>
<optional>true</optional>
</dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- <version>3.0.2</version>
- <optional>true</optional>
- </dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.device.MessageTranslator;
import org.opendaylight.openflowplugin.api.openflow.device.TranslatorLibrary;
*/
package org.opendaylight.openflowplugin.impl.common;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.impl.util.MatchUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.multipart.request.multipart.request.body.MultipartRequestDescBuilder;
*/
public static OfHeader makeMultipartRequest(final long xid,
final short version,
- @Nonnull final MultipartType type,
+ @NonNull final MultipartType type,
final boolean canUseSingleLayer) {
return canUseSingleLayer
? new MultipartRequestBuilder()
}
}
- private static MultipartRequestBody makeDefaultMultiLayerBody(@Nonnull final MultipartType type,
+ private static MultipartRequestBody makeDefaultMultiLayerBody(@NonNull final MultipartType type,
final short version) {
switch (type) {
case OFPMPDESC:
import java.util.List;
import java.util.Map;
import java.util.function.Function;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.configuration.ConfigurationListener;
import org.opendaylight.openflowplugin.api.openflow.configuration.ConfigurationProperty;
import org.opendaylight.openflowplugin.api.openflow.configuration.ConfigurationService;
}
@Override
- public void update(@Nonnull final Map<String, String> properties) {
+ public void update(@NonNull final Map<String, String> properties) {
properties.forEach((propertyName, newValue) -> {
final String originalValue = propertyMap.get(propertyName);
});
}
- @Nonnull
+ @NonNull
@Override
- public <T> T getProperty(@Nonnull final String key, @Nonnull final Function<String, T> transformer) {
+ public <T> T getProperty(@NonNull final String key, @NonNull final Function<String, T> transformer) {
return transformer.apply(propertyMap.get(key));
}
- @Nonnull
+ @NonNull
@Override
- public AutoCloseable registerListener(@Nonnull final ConfigurationListener listener) {
+ public AutoCloseable registerListener(@NonNull final ConfigurationListener listener) {
Verify.verify(!listeners.contains(listener));
LOG.info("{} was registered as configuration listener to OpenFlowPlugin configuration service", listener);
listeners.add(listener);
import com.google.common.util.concurrent.FutureCallback;
import java.util.function.Function;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueue;
import org.opendaylight.openflowplugin.api.openflow.connection.OutboundQueueProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.BarrierInput;
this.ofVersion = ofVersion;
}
- @Nonnull
+ @NonNull
@Override
- public BarrierInput createBarrierRequest(@Nonnull final Long xid) {
+ public BarrierInput createBarrierRequest(@NonNull final Long xid) {
final BarrierInputBuilder biBuilder = new BarrierInputBuilder();
biBuilder.setVersion(ofVersion);
biBuilder.setXid(xid);
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.EchoInputBuilder;
private final long echoReplyTimeout;
private final ExecutorService executorService;
- public SystemNotificationsListenerImpl(@Nonnull final ConnectionContext connectionContext,
+ public SystemNotificationsListenerImpl(@NonNull final ConnectionContext connectionContext,
final long echoReplyTimeout,
- @Nonnull final ExecutorService executorService) {
+ @NonNull final ExecutorService executorService) {
this.executorService = executorService;
this.connectionContext = Preconditions.checkNotNull(connectionContext);
this.echoReplyTimeout = echoReplyTimeout;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
private final NotificationManager<String, Runnable> queuedNotificationManager;
private final boolean isStatisticsPollingOn;
- DeviceContextImpl(@Nonnull final ConnectionContext primaryConnectionContext,
- @Nonnull final DataBroker dataBroker,
- @Nonnull final MessageSpy messageSpy,
- @Nonnull final TranslatorLibrary translatorLibrary,
+ DeviceContextImpl(@NonNull final ConnectionContext primaryConnectionContext,
+ @NonNull final DataBroker dataBroker,
+ @NonNull final MessageSpy messageSpy,
+ @NonNull final TranslatorLibrary translatorLibrary,
final ConvertorExecutor convertorExecutor,
final boolean skipTableFeatures,
final HashedWheelTimer hashedWheelTimer,
}
@Override
- public void registerMastershipWatcher(@Nonnull final ContextChainMastershipWatcher newWatcher) {
+ public void registerMastershipWatcher(@NonNull final ContextChainMastershipWatcher newWatcher) {
this.contextChainMastershipWatcher = newWatcher;
}
- @Nonnull
+ @NonNull
@Override
public ServiceGroupIdentifier getIdentifier() {
return deviceInfo.getServiceIdentifier();
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
private ContextChainHolder contextChainHolder;
private final QueuedNotificationManager<String, Runnable> queuedNotificationManager;
- public DeviceManagerImpl(@Nonnull final OpenflowProviderConfig config,
- @Nonnull final DataBroker dataBroker,
- @Nonnull final MessageSpy messageSpy,
- @Nonnull final NotificationPublishService notificationPublishService,
- @Nonnull final HashedWheelTimer hashedWheelTimer,
- @Nonnull final ConvertorExecutor convertorExecutor,
- @Nonnull final DeviceInitializerProvider deviceInitializerProvider,
- @Nonnull final ExecutorService executorService) {
+ public DeviceManagerImpl(@NonNull final OpenflowProviderConfig config,
+ @NonNull final DataBroker dataBroker,
+ @NonNull final MessageSpy messageSpy,
+ @NonNull final NotificationPublishService notificationPublishService,
+ @NonNull final HashedWheelTimer hashedWheelTimer,
+ @NonNull final ConvertorExecutor convertorExecutor,
+ @NonNull final DeviceInitializerProvider deviceInitializerProvider,
+ @NonNull final ExecutorService executorService) {
this.config = config;
this.dataBroker = dataBroker;
this.deviceInitializerProvider = deviceInitializerProvider;
}
@Override
- public ListenableFuture<?> removeDeviceFromOperationalDS(@Nonnull final KeyedInstanceIdentifier<Node, NodeKey> ii) {
+ public ListenableFuture<?> removeDeviceFromOperationalDS(@NonNull final KeyedInstanceIdentifier<Node, NodeKey> ii) {
final WriteTransaction delWtx = dataBroker.newWriteOnlyTransaction();
delWtx.delete(LogicalDatastoreType.OPERATIONAL, ii);
}
@Override
- public DeviceContext createContext(@Nonnull final ConnectionContext connectionContext) {
+ public DeviceContext createContext(@NonNull final ConnectionContext connectionContext) {
LOG.info("ConnectionEvent: Device connected to controller, Device:{}, NodeId:{}",
connectionContext.getConnectionAdapter().getRemoteAddress(),
}
@Override
- public void sendNodeRemovedNotification(@Nonnull final KeyedInstanceIdentifier<Node, NodeKey> instanceIdentifier) {
+ public void sendNodeRemovedNotification(@NonNull final KeyedInstanceIdentifier<Node, NodeKey> instanceIdentifier) {
if (notificationCreateNodeSend.remove(instanceIdentifier)) {
NodeRemovedBuilder builder = new NodeRemovedBuilder();
builder.setNodeRef(new NodeRef(instanceIdentifier));
}
@Override
- public void setContextChainHolder(@Nonnull final ContextChainHolder contextChainHolder) {
+ public void setContextChainHolder(@NonNull final ContextChainHolder contextChainHolder) {
this.contextChainHolder = contextChainHolder;
}
@Override
- public void sendNodeAddedNotification(@Nonnull final KeyedInstanceIdentifier<Node, NodeKey> instanceIdentifier) {
+ public void sendNodeAddedNotification(@NonNull final KeyedInstanceIdentifier<Node, NodeKey> instanceIdentifier) {
if (!notificationCreateNodeSend.contains(instanceIdentifier)) {
notificationCreateNodeSend.add(instanceIdentifier);
final NodeId id = instanceIdentifier.firstKeyOf(Node.class).getId();
import com.google.common.base.Preconditions;
import java.util.concurrent.atomic.AtomicInteger;
-import javax.annotation.concurrent.GuardedBy;
+import org.checkerframework.checker.lock.qual.GuardedBy;
+import org.checkerframework.checker.lock.qual.Holding;
abstract class SimpleRatelimiter {
private final AtomicInteger counter = new AtomicInteger();
}
}
- @GuardedBy("counterLock")
+ @Holding("counterLock")
private void resetLowWaterMark() {
lowWatermarkEffective = lowWatermark;
}
import com.google.common.util.concurrent.Futures;
import java.util.Collections;
import java.util.concurrent.Future;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.ConnectionException;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
* @param convertorExecutor convertor executor
*/
@SuppressWarnings("checkstyle:IllegalCatch")
- public Future<Void> initialize(@Nonnull final DeviceContext deviceContext,
+ public Future<Void> initialize(@NonNull final DeviceContext deviceContext,
final boolean switchFeaturesMandatory,
final boolean skipTableFeatures,
@Nullable final MultipartWriterProvider multipartWriterProvider,
multipartWriterProvider, convertorExecutor);
}
- protected abstract Future<Void> initializeNodeInformation(@Nonnull DeviceContext deviceContext,
+ protected abstract Future<Void> initializeNodeInformation(@NonNull DeviceContext deviceContext,
boolean switchFeaturesMandatory,
boolean skipTableFeatures,
@Nullable MultipartWriterProvider multipartWriterProvider,
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
private static final Logger LOG = LoggerFactory.getLogger(OF10DeviceInitializer.class);
@Override
- protected ListenableFuture<Void> initializeNodeInformation(@Nonnull final DeviceContext deviceContext,
+ protected ListenableFuture<Void> initializeNodeInformation(@NonNull final DeviceContext deviceContext,
final boolean switchFeaturesMandatory,
final boolean skipTableFeatures,
@Nullable final MultipartWriterProvider multipartWriterProvider,
import java.util.Optional;
import java.util.concurrent.Future;
import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
private static final Logger LOG = LoggerFactory.getLogger(OF13DeviceInitializer.class);
@Override
- protected Future<Void> initializeNodeInformation(@Nonnull final DeviceContext deviceContext,
+ protected Future<Void> initializeNodeInformation(@NonNull final DeviceContext deviceContext,
final boolean switchFeaturesMandatory,
final boolean skipTableFeatures,
@Nullable final MultipartWriterProvider multipartWriterProvider,
import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.List;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceReplyProcessor;
import org.opendaylight.openflowplugin.api.openflow.device.handlers.MultiMsgCollector;
}
@Override
- public void addMultipartMsg(@Nonnull final T reply, final boolean reqMore,
+ public void addMultipartMsg(@NonNull final T reply, final boolean reqMore,
@Nullable final EventIdentifier eventIdentifier) {
Preconditions.checkNotNull(reply);
Preconditions.checkNotNull(requestContext.getXid());
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListenerRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
}
@Override
- public void onNotAbleToStartMastership(@Nonnull final DeviceInfo deviceInfo, @Nonnull final String reason,
+ public void onNotAbleToStartMastership(@NonNull final DeviceInfo deviceInfo, @NonNull final String reason,
final boolean mandatory) {
LOG.warn("Not able to set MASTER role on device {}, reason: {}", deviceInfo, reason);
}
@Override
- public void onMasterRoleAcquired(@Nonnull final DeviceInfo deviceInfo,
- @Nonnull final ContextChainMastershipState mastershipState) {
+ public void onMasterRoleAcquired(@NonNull final DeviceInfo deviceInfo,
+ @NonNull final ContextChainMastershipState mastershipState) {
Optional.ofNullable(contextChainMap.get(deviceInfo)).ifPresent(contextChain -> {
if (ownershipChangeListener.isReconciliationFrameworkRegistered()
&& !ContextChainMastershipState.INITIAL_SUBMIT.equals(mastershipState)) {
LOG.debug("Context chain removed for node {}", deviceInfo);
}
- private FutureCallback<ResultState> reconciliationFrameworkCallback(@Nonnull final DeviceInfo deviceInfo,
+ private FutureCallback<ResultState> reconciliationFrameworkCallback(@NonNull final DeviceInfo deviceInfo,
final ContextChain contextChain, final ContextChainMastershipState mastershipState) {
return new FutureCallback<>() {
@Override
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.openflowplugin.api.openflow.OFPContext;
new AtomicReference<>(ContextChainState.UNDEFINED);
private AutoCloseable registration;
- ContextChainImpl(@Nonnull final ContextChainMastershipWatcher contextChainMastershipWatcher,
- @Nonnull final ConnectionContext connectionContext,
- @Nonnull final ExecutorService executorService) {
+ ContextChainImpl(@NonNull final ContextChainMastershipWatcher contextChainMastershipWatcher,
+ @NonNull final ConnectionContext connectionContext,
+ @NonNull final ExecutorService executorService) {
this.contextChainMastershipWatcher = contextChainMastershipWatcher;
this.primaryConnection = connectionContext;
this.deviceInfo = connectionContext.getDeviceInfo();
}
@Override
- public <T extends OFPContext> void addContext(@Nonnull final T context) {
+ public <T extends OFPContext> void addContext(@NonNull final T context) {
contexts.add(new GuardedContextImpl(context));
}
}, executorService);
}
- @Nonnull
+ @NonNull
@Override
public ServiceGroupIdentifier getIdentifier() {
return deviceInfo.getServiceIdentifier();
}
@Override
- public boolean isMastered(@Nonnull final ContextChainMastershipState mastershipState,
+ public boolean isMastered(@NonNull final ContextChainMastershipState mastershipState,
final boolean inReconciliationFrameworkStep) {
switch (mastershipState) {
case INITIAL_SUBMIT:
}
@Override
- public boolean addAuxiliaryConnection(@Nonnull final ConnectionContext connectionContext) {
+ public boolean addAuxiliaryConnection(@NonNull final ConnectionContext connectionContext) {
return connectionContext.getFeatures().getAuxiliaryId().toJava() != 0
&& !ConnectionContext.CONNECTION_STATE.RIP.equals(primaryConnection.getConnectionState())
&& auxiliaryConnections.add(connectionContext);
}
@Override
- public boolean auxiliaryConnectionDropped(@Nonnull final ConnectionContext connectionContext) {
+ public boolean auxiliaryConnectionDropped(@NonNull final ConnectionContext connectionContext) {
return auxiliaryConnections.remove(connectionContext);
}
@Override
- public void registerDeviceRemovedHandler(@Nonnull final DeviceRemovedHandler deviceRemovedHandler) {
+ public void registerDeviceRemovedHandler(@NonNull final DeviceRemovedHandler deviceRemovedHandler) {
deviceRemovedHandlers.add(deviceRemovedHandler);
}
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.Service;
import java.util.function.Function;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.openflowplugin.api.openflow.OFPContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
return result;
}
- @Nonnull
+ @NonNull
@Override
public ServiceGroupIdentifier getIdentifier() {
return delegate.getIdentifier();
}
@Override
- public void registerMastershipWatcher(@Nonnull final ContextChainMastershipWatcher contextChainMastershipWatcher) {
+ public void registerMastershipWatcher(@NonNull final ContextChainMastershipWatcher contextChainMastershipWatcher) {
delegate.registerMastershipWatcher(contextChainMastershipWatcher);
}
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
-import javax.annotation.Nonnull;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.lifecycle.MasterChecker;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeException;
private ReconciliationFrameworkEvent rfService = null;
private MasterChecker masterChecker;
- @Nonnull
+ @NonNull
@Override
- public MastershipChangeRegistration register(@Nonnull MastershipChangeService service) {
+ public MastershipChangeRegistration register(@NonNull MastershipChangeService service) {
final MastershipServiceDelegate registration =
new MastershipServiceDelegate(service, () -> serviceGroup.remove(service));
serviceGroup.add(service);
@Override
public ReconciliationFrameworkRegistration reconciliationFrameworkRegistration(
- @Nonnull ReconciliationFrameworkEvent reconciliationFrameworkEvent) throws MastershipChangeException {
+ @NonNull ReconciliationFrameworkEvent reconciliationFrameworkEvent) throws MastershipChangeException {
if (rfService != null) {
throw new MastershipChangeException("Reconciliation framework already registered.");
} else {
}
@Override
- public void becomeMaster(@Nonnull final DeviceInfo deviceInfo) {
+ public void becomeMaster(@NonNull final DeviceInfo deviceInfo) {
serviceGroup.forEach(mastershipChangeService -> mastershipChangeService.onBecomeOwner(deviceInfo));
}
@Override
- public void becomeSlaveOrDisconnect(@Nonnull final DeviceInfo deviceInfo) {
+ public void becomeSlaveOrDisconnect(@NonNull final DeviceInfo deviceInfo) {
if (rfService != null) {
ListenableFuture<Void> future = rfService.onDeviceDisconnected(deviceInfo);
// TODO This null future check here should ideally not be required, but some tests currently rely on it
}
@Override
- public ListenableFuture<ResultState> becomeMasterBeforeSubmittedDS(@Nonnull DeviceInfo deviceInfo) {
+ public ListenableFuture<ResultState> becomeMasterBeforeSubmittedDS(@NonNull DeviceInfo deviceInfo) {
return rfService == null ? null : rfService.onDevicePrepared(deviceInfo);
}
@Override
- public void setMasterChecker(@Nonnull final MasterChecker masterChecker) {
+ public void setMasterChecker(@NonNull final MasterChecker masterChecker) {
this.masterChecker = masterChecker;
}
*/
package org.opendaylight.openflowplugin.impl.mastership;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeRegistration;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeService;
}
@Override
- public void onBecomeOwner(@Nonnull final DeviceInfo deviceInfo) {
+ public void onBecomeOwner(@NonNull final DeviceInfo deviceInfo) {
this.service.onBecomeOwner(deviceInfo);
}
@Override
- public void onLoseOwnership(@Nonnull final DeviceInfo deviceInfo) {
+ public void onLoseOwnership(@NonNull final DeviceInfo deviceInfo) {
this.service.onLoseOwnership(deviceInfo);
}
package org.opendaylight.openflowplugin.impl.mastership;
import com.google.common.util.concurrent.ListenableFuture;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.mastership.ReconciliationFrameworkEvent;
import org.opendaylight.openflowplugin.api.openflow.mastership.ReconciliationFrameworkRegistration;
}
@Override
- public ListenableFuture<ResultState> onDevicePrepared(@Nonnull DeviceInfo deviceInfo) {
+ public ListenableFuture<ResultState> onDevicePrepared(@NonNull DeviceInfo deviceInfo) {
return this.service.onDevicePrepared(deviceInfo);
}
@Override
- public ListenableFuture<Void> onDeviceDisconnected(@Nonnull DeviceInfo deviceInfo) {
+ public ListenableFuture<Void> onDeviceDisconnected(@NonNull DeviceInfo deviceInfo) {
return this.service.onDeviceDisconnected(deviceInfo);
}
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
import io.netty.buffer.ByteBuf;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.impl.deserialization.match.OxmDeserializerHelper;
import org.opendaylight.openflowjava.util.ByteBufUtils;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
-import javax.annotation.Nonnull;
-import javax.annotation.concurrent.ThreadSafe;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-@ThreadSafe
+/*
+ * this class is marked to be thread safe
+ */
public class DeviceFlowRegistryImpl implements DeviceFlowRegistry {
private static final Logger LOG = LoggerFactory.getLogger(DeviceFlowRegistryImpl.class);
private static final String ALIEN_SYSTEM_FLOW_ID = "#UF$TABLE*";
}
@Override
- public FlowDescriptor retrieveDescriptor(@Nonnull final FlowRegistryKey flowRegistryKey) {
+ public FlowDescriptor retrieveDescriptor(@NonNull final FlowRegistryKey flowRegistryKey) {
if (LOG.isTraceEnabled()) {
LOG.trace("Retrieving flow descriptor for flow registry : {}", flowRegistryKey.toString());
}
}
@Override
- public void storeDescriptor(@Nonnull final FlowRegistryKey flowRegistryKey,
- @Nonnull final FlowDescriptor flowDescriptor) {
+ public void storeDescriptor(@NonNull final FlowRegistryKey flowRegistryKey,
+ @NonNull final FlowDescriptor flowDescriptor) {
try {
if (LOG.isTraceEnabled()) {
LOG.trace("Storing flowDescriptor with table ID : {} and flow ID : {} for flow hash : {}",
import static java.util.Objects.requireNonNull;
import com.google.common.base.Objects;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowDescriptor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
// Hide implicit constructor
}
- @Nonnull
- public static FlowDescriptor create(final Uint8 tableId, @Nonnull final FlowId flowId) {
+ @NonNull
+ public static FlowDescriptor create(final Uint8 tableId, @NonNull final FlowId flowId) {
return new FlowDescriptorDto(new TableKey(tableId), requireNonNull(flowId));
}
private final FlowId flowId;
private final TableKey tableKey;
- private FlowDescriptorDto(@Nonnull final TableKey tableKey, @Nonnull final FlowId flowId) {
+ private FlowDescriptorDto(@NonNull final TableKey tableKey, @NonNull final FlowId flowId) {
this.flowId = flowId;
this.tableKey = tableKey;
}
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import java.util.Objects;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowRegistryKey;
import org.opendaylight.openflowplugin.impl.util.MatchNormalizationUtil;
// Hide implicit constructor
}
- @Nonnull
- public static FlowRegistryKey create(final short version, @Nonnull final Flow flow) {
+ @NonNull
+ public static FlowRegistryKey create(final short version, @NonNull final Flow flow) {
//TODO: mandatory flow input values (or default values) should be specified via yang model
final Uint8 tableId = Preconditions.checkNotNull(flow.getTableId(), "flow tableId must not be null");
final Uint16 priority = MoreObjects.firstNonNull(flow.getPriority(), OFConstants.DEFAULT_FLOW_PRIORITY);
private FlowRegistryKeyDto(final short tableId,
final int priority,
- @Nonnull final Uint64 cookie,
- @Nonnull final Match match) {
+ @NonNull final Uint64 cookie,
+ @NonNull final Match match) {
this.tableId = tableId;
this.priority = priority;
this.cookie = cookie;
import java.util.Collections;
import java.util.List;
import java.util.function.Consumer;
-import javax.annotation.concurrent.ThreadSafe;
import org.opendaylight.openflowplugin.api.openflow.registry.group.DeviceGroupRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
-@ThreadSafe
+/*
+ * this class is marked to be thread safe
+ */
public class DeviceGroupRegistryImpl implements DeviceGroupRegistry {
private final List<GroupId> groupIds = Collections.synchronizedList(new ArrayList<>());
import java.util.Collections;
import java.util.List;
import java.util.function.Consumer;
-import javax.annotation.concurrent.ThreadSafe;
import org.opendaylight.openflowplugin.api.openflow.registry.meter.DeviceMeterRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
-@ThreadSafe
+/*
+ * this class is marked to be thread safe
+ */
public class DeviceMeterRegistryImpl implements DeviceMeterRegistry {
private final List<MeterId> meterIds = Collections.synchronizedList(new ArrayList<>());
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
private ContextChainMastershipWatcher contextChainMastershipWatcher;
private SalRoleService roleService;
- RoleContextImpl(@Nonnull final DeviceInfo deviceInfo,
- @Nonnull final HashedWheelTimer timer,
+ RoleContextImpl(@NonNull final DeviceInfo deviceInfo,
+ @NonNull final HashedWheelTimer timer,
final long checkRoleMasterTimeout,
final OpenflowProviderConfig config,
final ExecutorService executorService) {
}
@Override
- public void registerMastershipWatcher(@Nonnull final ContextChainMastershipWatcher newWatcher) {
+ public void registerMastershipWatcher(@NonNull final ContextChainMastershipWatcher newWatcher) {
this.contextChainMastershipWatcher = newWatcher;
}
return ret;
}
- @Nonnull
+ @NonNull
@Override
public ServiceGroupIdentifier getIdentifier() {
return deviceInfo.getServiceIdentifier();
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutorService;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.OFPContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
}
@Override
- public RoleContext createContext(@Nonnull final DeviceContext deviceContext) {
+ public RoleContext createContext(@NonNull final DeviceContext deviceContext) {
final DeviceInfo deviceInfo = deviceContext.getDeviceInfo();
final RoleContextImpl roleContext = new RoleContextImpl(
deviceContext.getDeviceInfo(),
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.Semaphore;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
private final NotificationPublishService notificationPublishService;
private ContextChainMastershipWatcher contextChainMastershipWatcher;
- RpcContextImpl(@Nonnull final RpcProviderService rpcProviderRegistry,
+ RpcContextImpl(@NonNull final RpcProviderService rpcProviderRegistry,
final int maxRequests,
- @Nonnull final DeviceContext deviceContext,
- @Nonnull final ExtensionConverterProvider extensionConverterProvider,
- @Nonnull final ConvertorExecutor convertorExecutor,
- @Nonnull final NotificationPublishService notificationPublishService,
+ @NonNull final DeviceContext deviceContext,
+ @NonNull final ExtensionConverterProvider extensionConverterProvider,
+ @NonNull final ConvertorExecutor convertorExecutor,
+ @NonNull final NotificationPublishService notificationPublishService,
final boolean statisticsRpcEnabled) {
this.deviceContext = deviceContext;
this.deviceInfo = deviceContext.getDeviceInfo();
}
@Override
- public void registerMastershipWatcher(@Nonnull final ContextChainMastershipWatcher newWatcher) {
+ public void registerMastershipWatcher(@NonNull final ContextChainMastershipWatcher newWatcher) {
this.contextChainMastershipWatcher = newWatcher;
}
contextChainMastershipWatcher.onMasterRoleAcquired(deviceInfo, ContextChainMastershipState.RPC_REGISTRATION);
}
- @Nonnull
+ @NonNull
@Override
public ServiceGroupIdentifier getIdentifier() {
return deviceInfo.getServiceIdentifier();
import java.util.Iterator;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
}
@Override
- public RpcContext createContext(final @Nonnull DeviceContext deviceContext) {
+ public RpcContext createContext(final @NonNull DeviceContext deviceContext) {
final RpcContextImpl rpcContext = new RpcContextImpl(
rpcProviderRegistry,
config.getRpcRequestsQuota().getValue().toJava(),
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
import java.util.function.Function;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
}
@Override
- public final ListenableFuture<RpcResult<List<T>>> handleServiceCall(@Nonnull final I input) {
+ public final ListenableFuture<RpcResult<List<T>>> handleServiceCall(@NonNull final I input) {
return canUseSingleLayerSerialization()
? super.handleServiceCall(input, ALTERNATE_IS_COMPLETE)
: super.handleServiceCall(input);
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FutureCallback;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowjava.protocol.api.connection.DeviceRequestFailedException;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.EventIdentifier;
context.close();
}
- protected final void spyMessage(@Nonnull final StatisticsGroup group) {
+ protected final void spyMessage(@NonNull final StatisticsGroup group) {
spy.spyMessage(requestType, Preconditions.checkNotNull(group));
}
}
@Override
- public final void onFailure(@Nonnull final Throwable throwable) {
+ public final void onFailure(@NonNull final Throwable throwable) {
final RpcResultBuilder<T> builder;
if (null != eventIdentifier) {
EventsTimeCounter.markEnd(eventIdentifier);
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.function.Function;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueue;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
protected abstract FutureCallback<OfHeader> createCallback(RequestContext<O> context, Class<?> requestType);
- public ListenableFuture<RpcResult<O>> handleServiceCall(@Nonnull final I input) {
+ public ListenableFuture<RpcResult<O>> handleServiceCall(@NonNull final I input) {
return handleServiceCall(input, null);
}
- public ListenableFuture<RpcResult<O>> handleServiceCall(@Nonnull final I input,
+ public ListenableFuture<RpcResult<O>> handleServiceCall(@NonNull final I input,
@Nullable final Function<OfHeader, Boolean> isComplete) {
Preconditions.checkNotNull(input);
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.function.Function;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
}
@Override
- public ListenableFuture<RpcResult<O>> handleServiceCall(@Nonnull I input,
+ public ListenableFuture<RpcResult<O>> handleServiceCall(@NonNull I input,
@Nullable final Function<OfHeader, Boolean> isComplete) {
return Futures.catching(
super.handleServiceCall(input, isComplete),
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.TransactionChainClosedException;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.openflowplugin.api.ConnectionException;
private StatisticsGatheringOnTheFlyService<T> statisticsGatheringOnTheFlyService;
private ContextChainMastershipWatcher contextChainMastershipWatcher;
- StatisticsContextImpl(@Nonnull final DeviceContext deviceContext,
- @Nonnull final ConvertorExecutor convertorExecutor,
- @Nonnull final MultipartWriterProvider statisticsWriterProvider,
- @Nonnull final ListeningExecutorService executorService,
- @Nonnull final OpenflowProviderConfig config,
+ StatisticsContextImpl(@NonNull final DeviceContext deviceContext,
+ @NonNull final ConvertorExecutor convertorExecutor,
+ @NonNull final MultipartWriterProvider statisticsWriterProvider,
+ @NonNull final ListeningExecutorService executorService,
+ @NonNull final OpenflowProviderConfig config,
final boolean isStatisticsPollingOn,
final boolean isUsingReconciliationFramework) {
this.deviceContext = deviceContext;
return this.deviceInfo;
}
- @Nonnull
+ @NonNull
@Override
public ServiceGroupIdentifier getIdentifier() {
return deviceInfo.getServiceIdentifier();
}
@Override
- public void registerMastershipWatcher(@Nonnull final ContextChainMastershipWatcher newWatcher) {
+ public void registerMastershipWatcher(@NonNull final ContextChainMastershipWatcher newWatcher) {
this.contextChainMastershipWatcher = newWatcher;
}
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.Semaphore;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
private final StatisticsWorkMode workMode = StatisticsWorkMode.COLLECTALL;
private boolean isStatisticsFullyDisabled;
- public StatisticsManagerImpl(@Nonnull final OpenflowProviderConfig config,
- @Nonnull final RpcProviderService rpcProviderRegistry,
+ public StatisticsManagerImpl(@NonNull final OpenflowProviderConfig config,
+ @NonNull final RpcProviderService rpcProviderRegistry,
final ConvertorExecutor convertorExecutor,
- @Nonnull final ListeningExecutorService executorService) {
+ @NonNull final ListeningExecutorService executorService) {
this.config = config;
this.converterExecutor = convertorExecutor;
this.controlServiceRegistration = Preconditions.checkNotNull(rpcProviderRegistry
}
@Override
- public StatisticsContext createContext(@Nonnull final DeviceContext deviceContext,
+ public StatisticsContext createContext(@NonNull final DeviceContext deviceContext,
final boolean useReconciliationFramework) {
final MultipartWriterProvider statisticsWriterProvider = MultipartWriterProviderFactory
.createDefaultProvider(deviceContext);
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.ConnectionException;
public class StatisticsPollingService extends AbstractScheduledService {
private final Supplier<ListenableFuture<Boolean>> gatheringSupplier;
private final SettableFuture<Void> future = SettableFuture.create();
- StatisticsPollingService(@Nonnull final TimeCounter counter,
+ StatisticsPollingService(@NonNull final TimeCounter counter,
final long pollingInterval,
final long maximumTimerDelay,
- @Nonnull final Supplier<ListenableFuture<Boolean>> gatheringSupplier) {
+ @NonNull final Supplier<ListenableFuture<Boolean>> gatheringSupplier) {
this.counter = counter;
this.pollingInterval = pollingInterval;
this.maximumTimerDelay = maximumTimerDelay;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicLongFieldUpdater;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageIntelligenceAgency;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
new ConcurrentHashMap<>();
@Override
- public void spyMessage(@Nonnull final Class<?> message, final StatisticsGroup statGroup) {
+ public void spyMessage(@NonNull final Class<?> message, final StatisticsGroup statGroup) {
Preconditions.checkNotNull(message, "Message can't be null.");
getCounters(message, statGroup).increment();
}
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Locale;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
import org.opendaylight.openflowplugin.openflow.md.util.InventoryDataServiceUtil;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
-import javax.annotation.Nonnull;
import org.apache.commons.lang3.tuple.Pair;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
}
public Function<List<RpcResult<O>>, RpcResult<List<BatchFailedFlowsOutput>>> invoke() {
- return (@Nonnull final List<RpcResult<O>> innerInput) -> {
+ return (@NonNull final List<RpcResult<O>> innerInput) -> {
final int sizeOfFutures = innerInput.size();
final int sizeOfInputBatch = inputBatchFlows.size();
Preconditions.checkArgument(sizeOfFutures == sizeOfInputBatch,
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
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;
* @param version the OpenFlow version
* @return normalized OpenFlow match
*/
- @Nonnull
- public static Match normalizeMatch(@Nonnull final Match match, final short version) {
+ @NonNull
+ public static Match normalizeMatch(@NonNull final Match match, final short version) {
final MatchBuilder matchBuilder = new MatchBuilder(match);
Optional.ofNullable(NORMALIZERS.get(version))
return matchBuilder.build();
}
- @Nonnull
+ @NonNull
private static Stream<Function<MatchBuilder, MatchBuilder>> createNormalizers(final short version) {
return Stream.of(
MatchNormalizationUtil::normalizeExtensionMatch,
(match) -> normalizeInPhyPortMatch(match, version));
}
- @Nonnull
- private static MatchBuilder normalizeExtensionMatch(@Nonnull final MatchBuilder match) {
+ @NonNull
+ private static MatchBuilder normalizeExtensionMatch(@NonNull final MatchBuilder match) {
return new MatchBuilder(MatchUtil.transformMatch(match.build(), Match.class));
}
- @Nonnull
+ @NonNull
@VisibleForTesting
- static MatchBuilder normalizeInPortMatch(@Nonnull final MatchBuilder match, final short version) {
+ static MatchBuilder normalizeInPortMatch(@NonNull final MatchBuilder match, final short version) {
return Optional
.ofNullable(match.getInPort())
.flatMap(inPort -> Optional.ofNullable(normalizeProtocolAgnosticPort(inPort, version)))
.orElse(match);
}
- @Nonnull
+ @NonNull
@VisibleForTesting
- static MatchBuilder normalizeInPhyPortMatch(@Nonnull final MatchBuilder match, final short version) {
+ static MatchBuilder normalizeInPhyPortMatch(@NonNull final MatchBuilder match, final short version) {
return Optional
.ofNullable(match.getInPhyPort())
.flatMap(inPhyPort -> Optional.ofNullable(normalizeProtocolAgnosticPort(inPhyPort, version)))
.orElse(match);
}
- @Nonnull
+ @NonNull
@VisibleForTesting
- static MatchBuilder normalizeArpMatch(@Nonnull final MatchBuilder match) {
+ static MatchBuilder normalizeArpMatch(@NonNull final MatchBuilder match) {
return Optional
.ofNullable(match.getLayer3Match())
.filter(ArpMatch.class::isInstance)
}
- @Nonnull
+ @NonNull
@VisibleForTesting
- static MatchBuilder normalizeTunnelIpv4Match(@Nonnull final MatchBuilder match) {
+ static MatchBuilder normalizeTunnelIpv4Match(@NonNull final MatchBuilder match) {
return Optional
.ofNullable(match.getLayer3Match())
.filter(TunnelIpv4Match.class::isInstance)
.orElse(match);
}
- @Nonnull
+ @NonNull
@VisibleForTesting
- static MatchBuilder normalizeIpv4Match(@Nonnull final MatchBuilder match) {
+ static MatchBuilder normalizeIpv4Match(@NonNull final MatchBuilder match) {
return Optional
.ofNullable(match.getLayer3Match())
.filter(Ipv4Match.class::isInstance)
.orElse(match);
}
- @Nonnull
+ @NonNull
@VisibleForTesting
- static MatchBuilder normalizeIpv4MatchArbitraryBitMask(@Nonnull final MatchBuilder match) {
+ static MatchBuilder normalizeIpv4MatchArbitraryBitMask(@NonNull final MatchBuilder match) {
return Optional
.ofNullable(match.getLayer3Match())
.filter(Ipv4MatchArbitraryBitMask.class::isInstance)
}
- @Nonnull
+ @NonNull
@VisibleForTesting
- static MatchBuilder normalizeIpv6Match(@Nonnull final MatchBuilder match) {
+ static MatchBuilder normalizeIpv6Match(@NonNull final MatchBuilder match) {
return Optional
.ofNullable(match.getLayer3Match())
.filter(Ipv6Match.class::isInstance)
}
- @Nonnull
+ @NonNull
@VisibleForTesting
- static MatchBuilder normalizeIpv6MatchArbitraryBitMask(@Nonnull final MatchBuilder match) {
+ static MatchBuilder normalizeIpv6MatchArbitraryBitMask(@NonNull final MatchBuilder match) {
return Optional
.ofNullable(match.getLayer3Match())
.filter(Ipv6MatchArbitraryBitMask.class::isInstance)
.orElse(match);
}
- @Nonnull
+ @NonNull
@VisibleForTesting
- static MatchBuilder normalizeEthernetMatch(@Nonnull final MatchBuilder match) {
+ static MatchBuilder normalizeEthernetMatch(@NonNull final MatchBuilder match) {
return Optional
.ofNullable(match.getEthernetMatch())
.map(eth -> match.setEthernetMatch(new EthernetMatchBuilder(eth)
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowplugin.openflow.md.core.extension.ExtensionResolvers;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
@Nullable
public static <T extends Match> T transformMatch(@Nullable final Match match,
- @Nonnull final Class<T> implementedInterface) {
+ @NonNull final Class<T> implementedInterface) {
if (match == null) {
return null;
}
import com.google.common.base.Preconditions;
import java.util.concurrent.atomic.AtomicLong;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.rpc.RpcContext;
*
* @param convertorExecutor convertor executor
*/
- public static void registerServices(@Nonnull final RpcContext rpcContext,
- @Nonnull final DeviceContext deviceContext,
+ public static void registerServices(@NonNull final RpcContext rpcContext,
+ @NonNull final DeviceContext deviceContext,
final ExtensionConverterProvider extensionConverterProvider,
final ConvertorExecutor convertorExecutor) {
// TODO: Use multipart writer provider from device context
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import java.util.List;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
import org.opendaylight.openflowplugin.openflow.md.util.InventoryDataServiceUtil;
* @return packet input converted to node connector reference
*/
@Nullable
- public static NodeConnectorRef toNodeConnectorRef(@Nonnull final PacketIn packetIn, final Uint64 dataPathId) {
+ public static NodeConnectorRef toNodeConnectorRef(@NonNull final PacketIn packetIn, final Uint64 dataPathId) {
Preconditions.checkNotNull(packetIn);
NodeConnectorRef ref = null;
*/
@SuppressWarnings("unchecked")
@Nullable
- public static Uint32 fromNodeConnectorRef(@Nonnull final NodeConnectorRef nodeConnectorRef, final short version) {
+ public static Uint32 fromNodeConnectorRef(@NonNull final NodeConnectorRef nodeConnectorRef, final short version) {
Preconditions.checkNotNull(nodeConnectorRef);
Uint32 port = null;
@VisibleForTesting
@Nullable
- static Uint32 getPortNoFromPacketIn(@Nonnull final PacketIn packetIn) {
+ static Uint32 getPortNoFromPacketIn(@NonNull final PacketIn packetIn) {
Preconditions.checkNotNull(packetIn);
Uint32 port = null;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import javax.inject.Inject;
import org.junit.After;
import org.junit.Assert;
}
@Override
- public void onDataTreeChanged(@Nonnull Collection<DataTreeModification<FlowCapableNode>> modifications) {
+ public void onDataTreeChanged(@NonNull Collection<DataTreeModification<FlowCapableNode>> modifications) {
for (DataTreeModification modification : modifications) {
if (modification.getRootNode().getModificationType() == ModificationType.WRITE) {
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
</dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- <version>3.0.2</version>
- <optional>true</optional>
- </dependency>
<dependency>
<groupId>org.slf4j</groupId>
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final CopyTtlInCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final CopyTtlInCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
CopyTtlInBuilder copyTtlInaction = new CopyTtlInBuilder();
return Optional.of(new CopyTtlInCaseBuilder().setCopyTtlIn(copyTtlInaction.build()).build());
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final CopyTtlOutCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final CopyTtlOutCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
CopyTtlOutBuilder copyTtlOutaction = new CopyTtlOutBuilder();
return Optional.of(new CopyTtlOutCaseBuilder().setCopyTtlOut(copyTtlOutaction.build()).build());
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final DecMplsTtlCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final DecMplsTtlCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
DecMplsTtlBuilder decMplsTtl = new DecMplsTtlBuilder();
return Optional.of(new DecMplsTtlCaseBuilder().setDecMplsTtl(decMplsTtl.build()).build());
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final DecNwTtlCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final DecNwTtlCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
DecNwTtlBuilder decNwTtl = new DecNwTtlBuilder();
return Optional.of(new DecNwTtlCaseBuilder().setDecNwTtl(decNwTtl.build()).build());
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final GroupCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final GroupCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
GroupAction groupActionFromOF = source.getGroupAction();
GroupActionBuilder groupAction = new GroupActionBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
}
@Override
- public Optional<Action> process(@Nonnull final OutputActionCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final OutputActionCase source, final ActionResponseConvertorData data,
final ConvertorExecutor convertorExecutor) {
final OpenflowVersion ofVersion = OpenflowVersion.get(data.getVersion());
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final PopMplsCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final PopMplsCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
PopMplsAction popMplsActionFromOF = source.getPopMplsAction();
PopMplsActionBuilder popMplsAction = new PopMplsActionBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final PopPbbCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final PopPbbCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
PopPbbActionBuilder popPbb = new PopPbbActionBuilder();
return Optional.of(new PopPbbActionCaseBuilder().setPopPbbAction(popPbb.build()).build());
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final PopVlanCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final PopVlanCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
PopVlanActionBuilder popVlan = new PopVlanActionBuilder();
return Optional.of(new PopVlanActionCaseBuilder().setPopVlanAction(popVlan.build()).build());
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final PushMplsCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final PushMplsCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
PushMplsAction pushMplsActionFromOF = source.getPushMplsAction();
PushMplsActionBuilder pushMplsAction = new PushMplsActionBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final PushPbbCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final PushPbbCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
PushPbbAction pushPbbActionFromOf = source.getPushPbbAction();
PushPbbActionBuilder pushPbbAction = new PushPbbActionBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final PushVlanCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final PushVlanCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
PushVlanAction pushVlanActionFromOF = source.getPushVlanAction();
PushVlanActionBuilder pushVlanAction = new PushVlanActionBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final SetDlDstCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final SetDlDstCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new SetDlDstActionCaseBuilder()
.setSetDlDstAction(new SetDlDstActionBuilder()
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final SetDlSrcCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final SetDlSrcCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new SetDlSrcActionCaseBuilder()
.setSetDlSrcAction(new SetDlSrcActionBuilder()
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final SetFieldCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final SetFieldCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final VersionDatapathIdConvertorData datapathIdConvertorData =
new VersionDatapathIdConvertorData(data.getVersion());
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final SetMplsTtlCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final SetMplsTtlCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
SetMplsTtlAction setMplsTtlActionFromOF = source.getSetMplsTtlAction();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final SetNwDstCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final SetNwDstCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new SetNwDstActionCaseBuilder()
.setSetNwDstAction(new SetNwDstActionBuilder().setAddress(new Ipv4Builder()
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final SetNwSrcCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final SetNwSrcCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new SetNwSrcActionCaseBuilder()
.setSetNwSrcAction(new SetNwSrcActionBuilder().setAddress(new Ipv4Builder()
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final SetNwTosCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final SetNwTosCase source, final ActionResponseConvertorData data,
final ConvertorExecutor convertorExecutor) {
return Optional.of(new SetNwTosActionCaseBuilder()
.setSetNwTosAction(new SetNwTosActionBuilder()
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final SetNwTtlCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final SetNwTtlCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
SetNwTtlAction setNwTtlActionFromOf = source.getSetNwTtlAction();
SetNwTtlActionBuilder setNwTtl = new SetNwTtlActionBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final SetQueueCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final SetQueueCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
SetQueueAction queueActionFromOF = source.getSetQueueAction();
SetQueueActionBuilder setQueueAction = new SetQueueActionBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final SetTpDstCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final SetTpDstCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new SetTpDstActionCaseBuilder()
.setSetTpDstAction(new SetTpDstActionBuilder()
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final SetTpSrcCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final SetTpSrcCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new SetTpSrcActionCaseBuilder()
.setSetTpSrcAction(new SetTpSrcActionBuilder()
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final SetVlanVidCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final SetVlanVidCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new SetVlanIdActionCaseBuilder()
.setSetVlanIdAction(new SetVlanIdActionBuilder()
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final SetVlanPcpCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final SetVlanPcpCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new SetVlanPcpActionCaseBuilder()
.setSetVlanPcpAction(new SetVlanPcpActionBuilder()
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionResponseConvertorData;
}
@Override
- public Optional<Action> process(@Nonnull final StripVlanCase source, final ActionResponseConvertorData data,
+ public Optional<Action> process(@NonNull final StripVlanCase source, final ActionResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
PopVlanActionBuilder popVlan = new PopVlanActionBuilder();
return Optional.of(new PopVlanActionCaseBuilder().setPopVlanAction(popVlan.build()).build());
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(CopyTtlInCase.class, true, OFConstants.OFP_VERSION_1_0, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final CopyTtlInCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final CopyTtlInCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new ActionBuilder()
.setActionChoice(new CopyTtlInCaseBuilder().build())
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(CopyTtlOutCase.class, true, OFConstants.OFP_VERSION_1_0, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final CopyTtlOutCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final CopyTtlOutCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new ActionBuilder()
.setActionChoice(new CopyTtlOutCaseBuilder().build())
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(DecMplsTtlCase.class, true, OFConstants.OFP_VERSION_1_0, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final DecMplsTtlCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final DecMplsTtlCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new ActionBuilder()
.setActionChoice(new DecMplsTtlCaseBuilder().build())
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(DecNwTtlCase.class, true, OFConstants.OFP_VERSION_1_0, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final DecNwTtlCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final DecNwTtlCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new ActionBuilder()
.setActionChoice(new DecNwTtlCaseBuilder().build())
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(DropActionCase.class, false, OFConstants.OFP_VERSION_1_0, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final DropActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final DropActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.empty();
}
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.extension.api.ConverterExtensionKey;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
super(GeneralExtensionGrouping.class, true, OFConstants.OFP_VERSION_1_0, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final GeneralExtensionGrouping source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final GeneralExtensionGrouping source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
final short version = data.getVersion();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(GroupActionCase.class, true, OFConstants.OFP_VERSION_1_0, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final GroupActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final GroupActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
GroupAction groupAction = source.getGroupAction();
GroupActionBuilder groupActionBuilder = new GroupActionBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
super(OutputActionCase.class, true, OFConstants.OFP_VERSION_1_0, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final OutputActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final OutputActionCase source, final ActionConvertorData data,
final ConvertorExecutor convertorExecutor) {
final OutputAction outputAction = source.getOutputAction();
final OutputActionBuilder outputBuilder = new OutputActionBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(PopMplsActionCase.class, true, OFConstants.OFP_VERSION_1_0, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final PopMplsActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final PopMplsActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
PopMplsCaseBuilder popMplsCaseBuilder = new PopMplsCaseBuilder();
PopMplsActionBuilder popMplsBuilder = new PopMplsActionBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(PopPbbActionCase.class, true, OFConstants.OFP_VERSION_1_0, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final PopPbbActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final PopPbbActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new ActionBuilder()
.setActionChoice(new PopPbbCaseBuilder().build())
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(PopVlanActionCase.class, true, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final PopVlanActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final PopVlanActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new ActionBuilder()
.setActionChoice(new PopVlanCaseBuilder().build())
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(PopVlanActionCase.class, true, OFConstants.OFP_VERSION_1_0);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final PopVlanActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final PopVlanActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new ActionBuilder()
.setActionChoice(new StripVlanCaseBuilder().build())
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(PushMplsActionCase.class, true, OFConstants.OFP_VERSION_1_0, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final PushMplsActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final PushMplsActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
PushMplsCaseBuilder pushMplsCaseBuilder = new PushMplsCaseBuilder();
PushMplsActionBuilder pushMplsBuilder = new PushMplsActionBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(PushPbbActionCase.class, true, OFConstants.OFP_VERSION_1_0, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final PushPbbActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final PushPbbActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
PushPbbCaseBuilder pushPbbCaseBuilder = new PushPbbCaseBuilder();
PushPbbActionBuilder pushPbbBuilder = new PushPbbActionBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(PushVlanActionCase.class, true, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final PushVlanActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final PushVlanActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
PushVlanAction pushVlanAction = source.getPushVlanAction();
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetDlDstActionCase.class, true, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetDlDstActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetDlDstActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
SetDlDstAction setdldstaction = source.getSetDlDstAction();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetDlDstActionCase.class, true, OFConstants.OFP_VERSION_1_0);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetDlDstActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetDlDstActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
SetDlDstAction setdldstaction = source.getSetDlDstAction();
SetDlDstCaseBuilder setDlDstCaseBuilder = new SetDlDstCaseBuilder();
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetDlSrcActionCase.class, true, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetDlSrcActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetDlSrcActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
SetDlSrcAction setdlsrcaction = source.getSetDlSrcAction();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetDlSrcActionCase.class, true, OFConstants.OFP_VERSION_1_0);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetDlSrcActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetDlSrcActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
SetDlSrcAction setdlsrcaction = source.getSetDlSrcAction();
SetDlSrcCaseBuilder setDlSrcCaseBuilder = new SetDlSrcCaseBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetFieldCase.class, true, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetFieldCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetFieldCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
final short version = data.getVersion();
final SetFieldActionBuilder setFieldBuilder = new SetFieldActionBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetFieldCase.class, true, OFConstants.OFP_VERSION_1_0);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetFieldCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetFieldCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
SetVlanVidCaseBuilder setVlanVidCaseBuilder = new SetVlanVidCaseBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetMplsTtlActionCase.class, true, OFConstants.OFP_VERSION_1_0, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetMplsTtlActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetMplsTtlActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
SetMplsTtlActionBuilder setMplsTtlBuilder = new SetMplsTtlActionBuilder()
.setMplsTtl(source.getSetMplsTtlAction().getMplsTtl());
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetNwDstActionCase.class, true, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetNwDstActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetNwDstActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
final ActionBuilder builder = new ActionBuilder();
final Address address = source.getSetNwDstAction().getAddress();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetNwDstActionCase.class, true, OFConstants.OFP_VERSION_1_0);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetNwDstActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetNwDstActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
final ActionBuilder builder = new ActionBuilder();
final Address address = source.getSetNwDstAction().getAddress();
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetNwSrcActionCase.class, true, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetNwSrcActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetNwSrcActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
final ActionBuilder builder = new ActionBuilder();
final Address address = source.getSetNwSrcAction().getAddress();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetNwSrcActionCase.class, true, OFConstants.OFP_VERSION_1_0);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetNwSrcActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetNwSrcActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
final ActionBuilder builder = new ActionBuilder();
final Address address = source.getSetNwSrcAction().getAddress();
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetNwTosActionCase.class, true, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetNwTosActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetNwTosActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
SetNwTosAction setnwtosaction = source.getSetNwTosAction();
SetFieldCaseBuilder setFieldCaseBuilder = new SetFieldCaseBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetNwTosActionCase.class, true, OFConstants.OFP_VERSION_1_0);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetNwTosActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetNwTosActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
SetNwTosAction setnwtosaction = source.getSetNwTosAction();
SetNwTosActionBuilder setNwTosActionBuilder = new SetNwTosActionBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetNwTtlActionCase.class, true, OFConstants.OFP_VERSION_1_0, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetNwTtlActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetNwTtlActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
SetNwTtlCaseBuilder nwTtlCaseBuilder = new SetNwTtlCaseBuilder();
SetNwTtlActionBuilder nwTtlBuilder = new SetNwTtlActionBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetQueueActionCase.class, true, OFConstants.OFP_VERSION_1_0, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetQueueActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetQueueActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
SetQueueAction setQueueAction = source.getSetQueueAction();
SetQueueCaseBuilder setQueueCaseBuilder = new SetQueueCaseBuilder();
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetTpDstActionCase.class, true, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetTpDstActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetTpDstActionCase source, final ActionConvertorData data,
final ConvertorExecutor convertorExecutor) {
IPProtocols protocol = null;
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetTpDstActionCase.class, true, OFConstants.OFP_VERSION_1_0);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetTpDstActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetTpDstActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
SetTpDstAction settpdstaction = source.getSetTpDstAction();
SetTpDstCaseBuilder setTpDstCaseBuilder = new SetTpDstCaseBuilder();
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetTpSrcActionCase.class, true, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetTpSrcActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetTpSrcActionCase source, final ActionConvertorData data,
final ConvertorExecutor convertorExecutor) {
IPProtocols protocol = null;
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetTpSrcActionCase.class, true, OFConstants.OFP_VERSION_1_0);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetTpSrcActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetTpSrcActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
SetTpSrcAction settpsrcaction = source.getSetTpSrcAction();
SetTpSrcCaseBuilder setTpSrcCaseBuilder = new SetTpSrcCaseBuilder();
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetVlanIdActionCase.class, true, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetVlanIdActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetVlanIdActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
MatchEntryBuilder matchBuilder = new MatchEntryBuilder();
matchBuilder.setOxmClass(OpenflowBasicClass.class);
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetVlanIdActionCase.class, true, OFConstants.OFP_VERSION_1_0);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetVlanIdActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetVlanIdActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
SetVlanIdAction setvlanidaction = source.getSetVlanIdAction();
SetVlanVidActionBuilder vlanidActionBuilder = new SetVlanVidActionBuilder();
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetVlanPcpActionCase.class, true, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetVlanPcpActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetVlanPcpActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
SetVlanPcpAction setvlanpcpaction = source.getSetVlanPcpAction();
SetFieldCaseBuilder setFieldCaseBuilder = new SetFieldCaseBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(SetVlanPcpActionCase.class, true, OFConstants.OFP_VERSION_1_0);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final SetVlanPcpActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final SetVlanPcpActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
SetVlanPcpAction setvlanpcpaction = source.getSetVlanPcpAction();
SetVlanPcpActionBuilder setVlanPcpActionBuilder = new SetVlanPcpActionBuilder();
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(StripVlanActionCase.class, true, OFConstants.OFP_VERSION_1_3);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final StripVlanActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final StripVlanActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
MatchEntryBuilder matchBuilder = new MatchEntryBuilder();
matchBuilder.setOxmClass(OpenflowBasicClass.class);
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
super(StripVlanActionCase.class, true, OFConstants.OFP_VERSION_1_0);
}
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final StripVlanActionCase source, final ActionConvertorData data,
+ public Optional<Action> process(@NonNull final StripVlanActionCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
return Optional.of(new ActionBuilder()
.setActionChoice(new StripVlanCaseBuilder().build())
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorActionToOFJava;
import org.opendaylight.openflowplugin.extension.api.TypeVersionKey;
}
@SuppressWarnings("unchecked")
- @Nonnull
+ @NonNull
@Override
- public Optional<Action> process(@Nonnull final org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112
+ public Optional<Action> process(final org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112
.action.Action source, final ActionConvertorData data, ConvertorExecutor convertorExecutor) {
final short version = data.getVersion();
final TypeVersionKey<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action> key =
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
/**
* @param convertorExecutor convertor executor
* @return the optional
*/
- public abstract Optional<T> process(@Nonnull F source, D data, ConvertorExecutor convertorExecutor);
+ public abstract Optional<T> process(@NonNull F source, D data, ConvertorExecutor convertorExecutor);
/**
* Should {@link org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorProcessor}
* @param convertorExecutor convertor executor
* @return the optional
*/
- Optional<T> processRaw(@Nonnull final Object source, final D data, final ConvertorExecutor convertorExecutor) {
+ Optional<T> processRaw(@NonNull final Object source, final D data, final ConvertorExecutor convertorExecutor) {
return process(getType().cast(source), data, convertorExecutor);
}
import java.util.Iterator;
import java.util.List;
import java.util.regex.Pattern;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IetfInetUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
}
@Override
- public Optional<Instruction> process(final @Nonnull org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
+ public Optional<Instruction> process(final org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
.rev131026.instruction.instruction.ApplyActionsCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
ApplyActions applyActions = source.getApplyActions();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.flow.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
}
@Override
- public Optional<Instruction> process(final @Nonnull org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
+ public Optional<Instruction> process(final org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
.rev131026.instruction.instruction.ClearActionsCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
ClearActionsCaseBuilder clearActionsCaseBuilder = new ClearActionsCaseBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.flow.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
}
@Override
- public Optional<Instruction> process(final @Nonnull org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
+ public Optional<Instruction> process(final org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
.rev131026.instruction.instruction.GoToTableCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
GoToTable goToTable = source.getGoToTable();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.flow.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
}
@Override
- public Optional<Instruction> process(final @Nonnull org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
+ public Optional<Instruction> process(final org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
.rev131026.instruction.instruction.MeterCase source, final ActionConvertorData data,
final ConvertorExecutor convertorExecutor) {
return Optional.of(new InstructionBuilder().setInstructionChoice(new MeterCaseBuilder()
import java.util.Collections;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
}
@Override
- public Optional<Instruction> process(final @Nonnull org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
+ public Optional<Instruction> process(final org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
.rev131026.instruction.instruction.WriteActionsCase source, final ActionConvertorData data,
ConvertorExecutor convertorExecutor) {
WriteActions writeActions = source.getWriteActions();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.flow.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.action.data.ActionConvertorData;
}
@Override
- public Optional<Instruction> process(final @Nonnull org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
+ public Optional<Instruction> process(final org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
.rev131026.instruction.instruction.WriteMetadataCase source, final ActionConvertorData data,
final ConvertorExecutor convertorExecutor) {
WriteMetadata writeMetadata = source.getWriteMetadata();
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Iterator;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Dscp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.Ipv6ExthdrFlags;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.IpDscp;
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull ArpOpCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull ArpOpCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final ArpMatchBuilder arpMatchBuilder = data.getArpMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowjava.util.ByteBufUtils;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull ArpShaCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull ArpShaCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final ArpMatchBuilder arpMatchBuilder = data.getArpMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull ArpSpaCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull ArpSpaCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final ArpMatchBuilder arpMatchBuilder = data.getArpMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowjava.util.ByteBufUtils;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull ArpThaCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull ArpThaCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final ArpMatchBuilder arpMatchBuilder = data.getArpMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull ArpTpaCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull ArpTpaCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final ArpMatchBuilder arpMatchBuilder = data.getArpMatchBuilder();
import static org.opendaylight.openflowjava.util.ByteBufUtils.macAddressToString;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull EthDstCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull EthDstCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final EthernetMatchBuilder ethMatchBuilder = data.getEthernetMatchBuilder();
import static org.opendaylight.openflowjava.util.ByteBufUtils.macAddressToString;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull EthSrcCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull EthSrcCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final EthernetMatchBuilder ethMatchBuilder = data.getEthernetMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull final EthTypeCase source, final MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull final EthTypeCase source, final MatchResponseConvertorData data,
final ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final EthType ethTypeCase = source.getEthType();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull ExperimenterIdCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull ExperimenterIdCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull final Icmpv4CodeCase source, final MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull final Icmpv4CodeCase source, final MatchResponseConvertorData data,
final ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final Icmpv4MatchBuilder icmpv4MatchBuilder = data.getIcmpv4MatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull final Icmpv4TypeCase source, final MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull final Icmpv4TypeCase source, final MatchResponseConvertorData data,
final ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final Icmpv4MatchBuilder icmpv4MatchBuilder = data.getIcmpv4MatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull final Icmpv6CodeCase source, final MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull final Icmpv6CodeCase source, final MatchResponseConvertorData data,
final ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final Icmpv6MatchBuilder icmpv6MatchBuilder = data.getIcmpv6MatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull final Icmpv6TypeCase source, final MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull final Icmpv6TypeCase source, final MatchResponseConvertorData data,
final ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final Icmpv6MatchBuilder icmpv6MatchBuilder = data.getIcmpv6MatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull final InPhyPortCase source, final MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull final InPhyPortCase source, final MatchResponseConvertorData data,
final ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final OpenflowVersion ofVersion = OpenflowVersion.get(data.getVersion());
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull final InPortCase source, final MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull final InPortCase source, final MatchResponseConvertorData data,
final ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final OpenflowVersion ofVersion = OpenflowVersion.get(data.getVersion());
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull IpDscpCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull IpDscpCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final IpMatchBuilder ipMatchBuilder = data.getIpMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull IpEcnCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull IpEcnCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final IpMatchBuilder ipMatchBuilder = data.getIpMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull final IpProtoCase source, final MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull final IpProtoCase source, final MatchResponseConvertorData data,
final ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final IpMatchBuilder ipMatchBuilder = data.getIpMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull final Ipv4DstCase source, final MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull final Ipv4DstCase source, final MatchResponseConvertorData data,
final ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final Ipv4MatchBuilder ipv4MatchBuilder = data.getIpv4MatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull Ipv4SrcCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull Ipv4SrcCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final Ipv4MatchBuilder ipv4MatchBuilder = data.getIpv4MatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull Ipv6DstCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull Ipv6DstCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final Ipv6MatchBuilder ipv6MatchBuilder = data.getIpv6MatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull Ipv6ExthdrCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull Ipv6ExthdrCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final Ipv6MatchBuilder ipv6MatchBuilder = data.getIpv6MatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull Ipv6FlabelCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull Ipv6FlabelCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final Ipv6MatchBuilder ipv6MatchBuilder = data.getIpv6MatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull Ipv6NdSllCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull Ipv6NdSllCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final Ipv6MatchBuilder ipv6MatchBuilder = data.getIpv6MatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull Ipv6NdTargetCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull Ipv6NdTargetCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final Ipv6MatchBuilder ipv6MatchBuilder = data.getIpv6MatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull Ipv6NdTllCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull Ipv6NdTllCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final Ipv6MatchBuilder ipv6MatchBuilder = data.getIpv6MatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull Ipv6SrcCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull Ipv6SrcCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final Ipv6MatchBuilder ipv6MatchBuilder = data.getIpv6MatchBuilder();
import java.math.BigInteger;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull MetadataCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull MetadataCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final MetadataBuilder metadataBuilder = new MetadataBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull MplsBosCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull MplsBosCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final ProtocolMatchFieldsBuilder protocolMatchFieldsBuilder = data.getProtocolMatchFieldsBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull MplsLabelCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull MplsLabelCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final ProtocolMatchFieldsBuilder protocolMatchFieldsBuilder = data.getProtocolMatchFieldsBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull MplsTcCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull MplsTcCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final ProtocolMatchFieldsBuilder protocolMatchFieldsBuilder = data.getProtocolMatchFieldsBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull final PacketTypeCase source,
+ public Optional<MatchBuilder> process(@NonNull final PacketTypeCase source,
final MatchResponseConvertorData data,
final ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull PbbIsidCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull PbbIsidCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final ProtocolMatchFieldsBuilder protocolMatchFieldsBuilder = data.getProtocolMatchFieldsBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull SctpDstCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull SctpDstCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final SctpMatchBuilder sctpMatchBuilder = data.getSctpMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull SctpSrcCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull SctpSrcCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final SctpMatchBuilder sctpMatchBuilder = data.getSctpMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull TcpDstCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull TcpDstCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final TcpMatchBuilder tcpMatchBuilder = data.getTcpMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull TcpSrcCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull TcpSrcCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final TcpMatchBuilder tcpMatchBuilder = data.getTcpMatchBuilder();
import java.math.BigInteger;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull TunnelIdCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull TunnelIdCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
import java.nio.ByteBuffer;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull Ipv4DstCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull Ipv4DstCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final Ipv4MatchBuilder ipv4MatchBuilder = data.getIpv4MatchBuilder();
import java.nio.ByteBuffer;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull Ipv4SrcCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull Ipv4SrcCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final Ipv4MatchBuilder ipv4MatchBuilder = data.getIpv4MatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull UdpDstCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull UdpDstCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final UdpMatchBuilder udpMatchBuilder = data.getUdpMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull UdpSrcCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull UdpSrcCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final UdpMatchBuilder udpMatchBuilder = data.getUdpMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull VlanPcpCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull VlanPcpCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final VlanMatchBuilder vlanMatchBuilder = data.getVlanMatchBuilder();
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.cases;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<MatchBuilder> process(@Nonnull VlanVidCase source, MatchResponseConvertorData data,
+ public Optional<MatchBuilder> process(@NonNull VlanVidCase source, MatchResponseConvertorData data,
ConvertorExecutor convertorExecutor) {
final MatchBuilder matchBuilder = data.getMatchBuilder();
final VlanMatchBuilder vlanMatchBuilder = data.getVlanMatchBuilder();
import java.util.Iterator;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowjava.util.ByteBufUtils;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
}
@Override
- public Optional<List<MatchEntry>> process(@Nonnull ArpMatch source, VersionConvertorData data,
+ public Optional<List<MatchEntry>> process(@NonNull ArpMatch source, VersionConvertorData data,
ConvertorExecutor convertorExecutor) {
List<MatchEntry> result = new ArrayList<>();
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
}
@Override
- public Optional<List<MatchEntry>> process(@Nonnull Ipv4MatchArbitraryBitMask source, VersionConvertorData data,
+ public Optional<List<MatchEntry>> process(@NonNull Ipv4MatchArbitraryBitMask source, VersionConvertorData data,
ConvertorExecutor convertorExecutor) {
List<MatchEntry> result = new ArrayList<>();
import java.util.Iterator;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
}
@Override
- public Optional<List<MatchEntry>> process(@Nonnull Ipv4Match source, VersionConvertorData data,
+ public Optional<List<MatchEntry>> process(@NonNull Ipv4Match source, VersionConvertorData data,
ConvertorExecutor convertorExecutor) {
List<MatchEntry> result = new ArrayList<>();
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
}
@Override
- public Optional<List<MatchEntry>> process(@Nonnull Ipv6MatchArbitraryBitMask source, VersionConvertorData data,
+ public Optional<List<MatchEntry>> process(@NonNull Ipv6MatchArbitraryBitMask source, VersionConvertorData data,
ConvertorExecutor convertorExecutor) {
List<MatchEntry> result = new ArrayList<>();
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
}
@Override
- public Optional<List<MatchEntry>> process(@Nonnull final Ipv6Match source, final VersionConvertorData data,
+ public Optional<List<MatchEntry>> process(@NonNull final Ipv6Match source, final VersionConvertorData data,
final ConvertorExecutor convertorExecutor) {
List<MatchEntry> result = new ArrayList<>();
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.data.VersionConvertorData;
}
@Override
- public Optional<List<MatchEntry>> process(@Nonnull SctpMatch source, VersionConvertorData data,
+ public Optional<List<MatchEntry>> process(@NonNull SctpMatch source, VersionConvertorData data,
ConvertorExecutor convertorExecutor) {
List<MatchEntry> result = new ArrayList<>();
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.data.VersionConvertorData;
}
@Override
- public Optional<List<MatchEntry>> process(@Nonnull TcpMatch source, VersionConvertorData data,
+ public Optional<List<MatchEntry>> process(@NonNull TcpMatch source, VersionConvertorData data,
ConvertorExecutor convertorExecutor) {
List<MatchEntry> result = new ArrayList<>();
import java.util.Iterator;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
}
@Override
- public Optional<List<MatchEntry>> process(@Nonnull TunnelIpv4Match source, VersionConvertorData data,
+ public Optional<List<MatchEntry>> process(@NonNull TunnelIpv4Match source, VersionConvertorData data,
ConvertorExecutor convertorExecutor) {
List<MatchEntry> result = new ArrayList<>();
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.ConvertorCase;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.data.VersionConvertorData;
}
@Override
- public Optional<List<MatchEntry>> process(@Nonnull UdpMatch source, VersionConvertorData data,
+ public Optional<List<MatchEntry>> process(@NonNull UdpMatch source, VersionConvertorData data,
ConvertorExecutor convertorExecutor) {
List<MatchEntry> result = new ArrayList<>();
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.math.BigInteger;
import java.util.Arrays;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
import com.google.common.base.Strings;
import java.math.BigInteger;
import java.util.List;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
}
@Nullable
- public static Uint32 portNumberfromNodeConnectorId(final OpenflowVersion ofVersion, @Nonnull final String ncId) {
+ public static Uint32 portNumberfromNodeConnectorId(final OpenflowVersion ofVersion, @NonNull final String ncId) {
String portNoString = portNoStringfromNodeConnectorID(ncId);
return OpenflowPortsUtil.getPortFromLogicalName(ofVersion, portNoString);
}
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.Maps;
import java.util.Objects;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowjava.protocol.api.util.BinContent;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
<artifactId>javax.annotation-api</artifactId>
<optional>true</optional>
</dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- <version>3.0.2</version>
- <optional>true</optional>
- </dependency>
<dependency>
<groupId>org.opendaylight.openflowplugin.model</groupId>
<artifactId>model-flow-base</artifactId>
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.atomic.AtomicLong;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
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.flow.inventory.rev130819.FlowId;
private Map<MacAddress, NodeConnectorRef> mac2portMapping;
private final Set<String> coveredMacPaths = new HashSet<>();
- public LearningSwitchHandlerSimpleImpl(@Nonnull FlowCommitWrapper dataStoreAccessor,
- @Nonnull PacketProcessingService packetProcessingService,
+ public LearningSwitchHandlerSimpleImpl(@NonNull FlowCommitWrapper dataStoreAccessor,
+ @NonNull PacketProcessingService packetProcessingService,
@Nullable DataTreeChangeListenerRegistrationHolder registrationPublisher) {
this.dataStoreAccessor = Objects.requireNonNull(dataStoreAccessor);
this.packetProcessingService = Objects.requireNonNull(packetProcessingService);
package org.opendaylight.openflowplugin.learningswitch;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
private LearningSwitchHandler learningSwitchHandler;
@Override
- public void onDataTreeChanged(@Non
null Collection<DataTreeModification<Table>> modifications) {
+ public void onDataTreeChanged(@Non
Null Collection<DataTreeModification<Table>> modifications) {
Uint8 requiredTableId = Uint8.ZERO;
// TODO add flow
package org.opendaylight.openflowplugin.learningswitch.multi;
import java.util.Objects;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.learningswitch.FlowCommitWrapper;
import org.opendaylight.openflowplugin.learningswitch.InstanceIdentifierUtils;
import org.opendaylight.openflowplugin.learningswitch.LearningSwitchHandler;
private final PacketProcessingService packetProcessingService;
private final PacketInDispatcherImpl packetInDispatcher;
- public MultipleLearningSwitchHandlerFacadeImpl(@Nonnull FlowCommitWrapper dataStoreAccessor,
- @Nonnull PacketProcessingService packetProcessingService,
- @Nonnull PacketInDispatcherImpl packetInDispatcher) {
+ public MultipleLearningSwitchHandlerFacadeImpl(@NonNull FlowCommitWrapper dataStoreAccessor,
+ @NonNull PacketProcessingService packetProcessingService,
+ @NonNull PacketInDispatcherImpl packetInDispatcher) {
this.dataStoreAccessor = Objects.requireNonNull(dataStoreAccessor);
this.packetProcessingService = Objects.requireNonNull(packetProcessingService);
this.packetInDispatcher = Objects.requireNonNull(packetInDispatcher);
Code Review / openflowplugin.git / commitdiff