<build>
<plugins>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <configuration>
+ <instructions>
+ <Import-Package>!javax.annotation,*</Import-Package>
+ </instructions>
+ </configuration>
+ </plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
import java.util.Collection;
import java.util.EventListener;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
/**
- * Interface implemented by classes interested in receiving notifications about
- * data tree changes. It provides a cursor-based view of the change.
+ * Interface implemented by classes interested in receiving notifications about data tree changes. It provides
+ * a cursor-based view of the change.
*/
public interface DOMDataTreeChangeListener extends EventListener {
/**
- * Invoked when there was data change for the supplied path, which was used
- * to register this listener.
+ * Invoked when there was data change for the supplied path, which was used to register this listener.
*
* <p>
- * This method may be also invoked during registration of the listener if
- * there is any pre-existing data in the conceptual data tree for supplied
- * path. This initial event will contain all pre-existing data as created.
+ * This method may be also invoked during registration of the listener if there is any pre-existing data
+ * in the conceptual data tree for supplied path. This initial event will contain all pre-existing data as created.
*
* <p>
- * A data change event may be triggered spuriously, e.g. such that data before
- * and after compare as equal. Implementations of this interface are expected
- * to recover from such events. Event producers are expected to exert reasonable
- * effort to suppress such events.
- * In other words, it is completely acceptable to observe
- * a {@link org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode},
- * which reports a {@link org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType}
- * other than UNMODIFIED, while the before- and after- data items compare as
- * equal.
+ * A data change event may be triggered spuriously, e.g. such that data before and after compare as equal.
+ * Implementations of this interface are expected to recover from such events. Event producers are expected to exert
+ * reasonable effort to suppress such events. In other words, it is completely acceptable to observe
+ * a {@link org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode}, which reports
+ * a {@link org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType} other than UNMODIFIED, while
+ * the before- and after- data items compare as equal.
*
* @param changes Collection of change events, may not be null or empty.
+ * @throws NullPointerException if {@code changes} is null
*/
- void onDataTreeChanged(@Nonnull Collection<DataTreeCandidate> changes);
+ void onDataTreeChanged(@NonNull Collection<DataTreeCandidate> changes);
}
*/
package org.opendaylight.mdsal.dom.api;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
/**
* @param <L> Listener type
* @return Listener registration object, which may be used to unregister your listener using
* {@link ListenerRegistration#close()} to stop delivery of change events.
+ * @throws NullPointerException if any of the arguments is null
*/
- @Nonnull <L extends DOMDataTreeChangeListener> ListenerRegistration<L>
- registerDataTreeChangeListener(@Nonnull DOMDataTreeIdentifier treeId, @Nonnull L listener);
+ <L extends DOMDataTreeChangeListener> @NonNull ListenerRegistration<L> registerDataTreeChangeListener(
+ @NonNull DOMDataTreeIdentifier treeId, @NonNull L listener);
}
*/
package org.opendaylight.mdsal.dom.api;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.util.concurrent.FluentFuture;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.DataValidationFailedException;
import org.opendaylight.mdsal.common.api.PostCanCommitStep;
import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
* more specific subclasses of this exception to provide additional information about
* validation failure reason.
*/
- @Nonnull
- FluentFuture<PostCanCommitStep> canCommit(@Nonnull Object txId,
- @Nonnull SchemaContext ctx, @Nonnull Collection<DOMDataTreeCandidate> candidates);
+ @NonNull FluentFuture<PostCanCommitStep> canCommit(@NonNull Object txId,
+ @NonNull SchemaContext ctx, @NonNull Collection<DOMDataTreeCandidate> candidates);
/**
* An ExceptionMapper that translates an Exception to a DataValidationFailedException.
*/
class DataValidationFailedExceptionMapper extends ExceptionMapper<DataValidationFailedException> {
- private final DOMDataTreeIdentifier failedTreeId;
+ private final @NonNull DOMDataTreeIdentifier failedTreeId;
public DataValidationFailedExceptionMapper(final String opName, final DOMDataTreeIdentifier failedTreeId) {
super(opName, DataValidationFailedException.class);
- this.failedTreeId = failedTreeId;
+ this.failedTreeId = requireNonNull(failedTreeId);
}
@Override
import com.google.common.annotations.Beta;
import java.util.Arrays;
-import javax.annotation.Nonnull;
import javax.annotation.concurrent.NotThreadSafe;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
* @throws IllegalArgumentException when specified identifier does not identify a valid child,
* or if that child is not an instance of {@link NormalizedNodeContainer}.
*/
- void enter(@Nonnull PathArgument child);
+ void enter(@NonNull PathArgument child);
/**
* Move the cursor to the specified child of the current position. This is the equivalent of
* @throws IllegalArgumentException when specified path does not identify a valid child, or if
* that child is not an instance of {@link NormalizedNodeContainer}.
*/
- default void enter(@Nonnull final PathArgument... path) {
+ default void enter(final @NonNull PathArgument... path) {
enter(Arrays.asList(path));
}
* @throws IllegalArgumentException when specified path does not identify a valid child, or if
* that child is not an instance of {@link NormalizedNodeContainer}.
*/
- void enter(@Non
null Iterable<PathArgument> path);
+ void enter(@Non
Null Iterable<PathArgument> path);
/**
* Move the cursor up to the parent of current position. This is equivalent of invoking
package org.opendaylight.mdsal.dom.api;
import com.google.common.util.concurrent.FluentFuture;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
* @throws IllegalStateException when there's an open cursor, or this transaction is closed already.
*/
@Override
- @Nullable DOMDataTreeWriteCursor createCursor(@Nonnull DOMDataTreeIdentifier path);
+ DOMDataTreeWriteCursor createCursor(DOMDataTreeIdentifier path);
/**
* Cancels the transaction.
*/
package org.opendaylight.mdsal.dom.api;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModificationCursor;
public interface DOMDataTreeCursorProvider {
-
/**
* Create a new {@link DataTreeModificationCursor} at specified path. May fail if specified path
* does not exist.
* @throws IllegalStateException if there is another cursor currently open, or the transaction
* is already closed (closed or submitted).
*/
- @Nullable
- DOMDataTreeCursor createCursor(@Nonnull DOMDataTreeIdentifier path);
-
+ @Nullable DOMDataTreeCursor createCursor(@NonNull DOMDataTreeIdentifier path);
}
import java.util.Collection;
import java.util.EventListener;
import java.util.Map;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
* This includes all the subtrees this listener is subscribed to, even those
* which have not changed.
*/
- void onDataTreeChanged(@Nonnull Collection<DataTreeCandidate> changes,
- @Nonnull Map<DOMDataTreeIdentifier, NormalizedNode<?, ?>> subtrees);
+ void onDataTreeChanged(@NonNull Collection<DataTreeCandidate> changes,
+ @NonNull Map<DOMDataTreeIdentifier, NormalizedNode<?, ?>> subtrees);
/**
* Invoked when a subtree listening failure occurs. This can be triggered, for example, when a
*
* @param causes Collection of failure causes, may not be null or empty.
*/
- void onDataTreeFailed(@Nonnull Collection<DOMDataTreeListeningException> causes);
+ void onDataTreeFailed(@NonNull Collection<DOMDataTreeListeningException> causes);
}
*/
package org.opendaylight.mdsal.dom.api;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* Exception thrown when a loop is detected in the way {@link DOMDataTreeListener}
public class DOMDataTreeLoopException extends Exception {
private static final long serialVersionUID = 1L;
- public DOMDataTreeLoopException(@Nonnull final String message) {
+ public DOMDataTreeLoopException(@NonNull final String message) {
super(message);
}
- public DOMDataTreeLoopException(@Nonnull final String message, @Nonnull final Throwable cause) {
+ public DOMDataTreeLoopException(@NonNull final String message, @NonNull final Throwable cause) {
super(message, cause);
}
}
package org.opendaylight.mdsal.dom.api;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* A data producer context. It allows transactions to be submitted to the subtrees
* exception is thrown on a best effort basis and programs should not rely on it for
* correct operation.
*/
- @Nonnull DOMDataTreeCursorAwareTransaction createTransaction(boolean isolated);
+ @NonNull DOMDataTreeCursorAwareTransaction createTransaction(boolean isolated);
/**
* {@inheritDoc}.
* correct operation.
*/
@Override
- @Nonnull DOMDataTreeProducer createProducer(@Nonnull Collection<DOMDataTreeIdentifier> subtrees);
+ DOMDataTreeProducer createProducer(Collection<DOMDataTreeIdentifier> subtrees);
/**
* {@inheritDoc}.
package org.opendaylight.mdsal.dom.api;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* Base source of {@link DOMDataTreeProducer}s. This interface is usually not used directly,
* @return A {@link DOMDataTreeProducer} instance.
* @throws IllegalArgumentException if subtrees is empty.
*/
- @Nonnull DOMDataTreeProducer createProducer(@Nonnull Collection<DOMDataTreeIdentifier> subtrees);
+ @NonNull DOMDataTreeProducer createProducer(@NonNull Collection<DOMDataTreeIdentifier> subtrees);
}
import com.google.common.util.concurrent.FluentFuture;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public interface DOMDataTreeReadCursor extends DOMDataTreeCursor {
-
/**
* Read a particular node from the snapshot.
*
* </ul>
* @throws IllegalArgumentException when specified path does not identify a valid child.
*/
- FluentFuture<Optional<NormalizedNode<?, ?>>> readNode(@Nonnull PathArgument child);
+ @NonNull FluentFuture<Optional<NormalizedNode<?, ?>>> readNode(@NonNull PathArgument child);
/**
* Checks if data is available in the logical data store located at provided path.
* ReadFailedException.</li>
* </ul>
*/
- FluentFuture<Boolean> exists(@Nonnull PathArgument child);
+ @NonNull FluentFuture<Boolean> exists(@NonNull PathArgument child);
}
package org.opendaylight.mdsal.dom.api;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
/**
* subtrees with specified producers would form a
* feedback loop
*/
- @Nonnull <T extends DOMDataTreeListener> ListenerRegistration<T> registerListener(@Nonnull T listener,
- @Nonnull Collection<DOMDataTreeIdentifier> subtrees, boolean allowRxMerges,
- @Nonnull Collection<DOMDataTreeProducer> producers) throws DOMDataTreeLoopException;
+ @NonNull <T extends DOMDataTreeListener> ListenerRegistration<T> registerListener(@NonNull T listener,
+ @NonNull Collection<DOMDataTreeIdentifier> subtrees, boolean allowRxMerges,
+ @NonNull Collection<DOMDataTreeProducer> producers) throws DOMDataTreeLoopException;
}
package org.opendaylight.mdsal.dom.api;
import java.util.EventListener;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* A single shard of the conceptual data tree. This interface defines the basic notifications
* @param prefix Child's prefix
* @param child Child shard
*/
- void onChildAttached(@Nonnull DOMDataTreeIdentifier prefix, @Nonnull DOMDataTreeShard child);
+ void onChildAttached(@NonNull DOMDataTreeIdentifier prefix, @NonNull DOMDataTreeShard child);
/**
* Invoked whenever a child is getting detached as a more specific prefix under this shard.
* @param prefix Child's prefix
* @param child Child shard
*/
- void onChildDetached(@Nonnull DOMDataTreeIdentifier prefix, @Nonnull DOMDataTreeShard child);
+ void onChildDetached(@NonNull DOMDataTreeIdentifier prefix, @NonNull DOMDataTreeShard child);
}
*/
package org.opendaylight.mdsal.dom.api;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* Exception thrown when an attempt to attach a conflicting shard to the global
public class DOMDataTreeShardingConflictException extends Exception {
private static final long serialVersionUID = 1L;
- public DOMDataTreeShardingConflictException(@Nonnull final String message) {
+ public DOMDataTreeShardingConflictException(final @NonNull String message) {
super(message);
}
- public DOMDataTreeShardingConflictException(@Nonnull final String message, @Nonnull final Throwable cause) {
+ public DOMDataTreeShardingConflictException(final @NonNull String message, final @NonNull Throwable cause) {
super(message, cause);
}
}
*/
package org.opendaylight.mdsal.dom.api;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
/**
* @return A registration. To remove the shard's binding, close the registration.
* @throws DOMDataTreeShardingConflictException if the prefix is already bound
*/
- @Nonnull <T extends DOMDataTreeShard> ListenerRegistration<T> registerDataTreeShard(
- @Nonnull DOMDataTreeIdentifier prefix, @Nonnull T shard,
- @Nonnull DOMDataTreeProducer producer) throws DOMDataTreeShardingConflictException;
+ <T extends DOMDataTreeShard> @NonNull ListenerRegistration<T> registerDataTreeShard(
+ @NonNull DOMDataTreeIdentifier prefix, @NonNull T shard,
+ @NonNull DOMDataTreeProducer producer) throws DOMDataTreeShardingConflictException;
}
*/
package org.opendaylight.mdsal.dom.api;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
*
* @return Notification type.
*/
- @Nonnull SchemaPath getType();
+ @NonNull SchemaPath getType();
/**
* Return the body of this notification.
*
* @return Notification body.
*/
- @Nonnull ContainerNode getBody();
+ @NonNull ContainerNode getBody();
}
package org.opendaylight.mdsal.dom.api;
import java.util.EventListener;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* Interface implemented by listeners interested in {@link DOMNotification}s.
*
* @param notification Received notification
*/
- void onNotification(@Nonnull DOMNotification notification);
+ void onNotification(@NonNull DOMNotification notification);
}
*/
package org.opendaylight.mdsal.dom.api;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.TimeUnit;
import javax.annotation.Nonnegative;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
/**
* A {@link DOMService} which allows its user to send {@link DOMNotification}s. It
* Well-known value indicating that the implementation is currently not
* able to accept a notification.
*/
- ListenableFuture<Object> REJECTED = Futures.immediateFailedFuture(
+ ListenableFuture<Object> REJECTED = FluentFutures.immediateFailedFluentFuture(
new DOMNotificationRejectedException("Unacceptable blocking conditions encountered"));
/**
* @throws InterruptedException if interrupted while waiting
* @throws NullPointerException if notification is null.
*/
- @Nonnull ListenableFuture<? extends Object> putNotification(@Nonnull DOMNotification notification)
+ @NonNull ListenableFuture<? extends Object> putNotification(@NonNull DOMNotification notification)
throws InterruptedException;
/**
* delivery.
* @throws NullPointerException if notification is null.
*/
- @Nonnull ListenableFuture<? extends Object> offerNotification(@Nonnull DOMNotification notification);
+ @NonNull ListenableFuture<? extends Object> offerNotification(@NonNull DOMNotification notification);
/**
* Attempt to publish a notification. The result of this method is a {@link ListenableFuture}
* @throws NullPointerException if notification or unit is null.
* @throws IllegalArgumentException if timeout is negative.
*/
- @Nonnull ListenableFuture<? extends Object> offerNotification(@Nonnull DOMNotification notification,
- @Nonnegative long timeout, @Nonnull TimeUnit unit) throws InterruptedException;
+ @NonNull ListenableFuture<? extends Object> offerNotification(@NonNull DOMNotification notification,
+ @Nonnegative long timeout, @NonNull TimeUnit unit) throws InterruptedException;
}
package org.opendaylight.mdsal.dom.api;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
* @throws NullPointerException if either of the arguments is null
*/
<T extends DOMNotificationListener> ListenerRegistration<T>
- registerNotificationListener(@Nonnull T listener, @Nonnull Collection<SchemaPath> types);
+ registerNotificationListener(@NonNull T listener, @NonNull Collection<SchemaPath> types);
/**
* Register a {@link DOMNotificationListener} to receive a set of notifications. As with other
*/
// FIXME: Java 8: provide a default implementation of this method.
<T extends DOMNotificationListener> ListenerRegistration<T>
- registerNotificationListener(@Nonnull T listener, SchemaPath... types);
+ registerNotificationListener(@NonNull T listener, SchemaPath... types);
}
import java.util.Collection;
import java.util.EventListener;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* An {@link EventListener} used to track RPC implementations becoming (un)available
*
* @param rpcs RPC types newly available
*/
- void onRpcAvailable(@Nonnull Collection<DOMRpcIdentifier> rpcs);
+ void onRpcAvailable(@NonNull Collection<DOMRpcIdentifier> rpcs);
/**
* Method invoked whenever an RPC type becomes unavailable.
*
* @param rpcs RPC types which became unavailable
*/
- void onRpcUnavailable(@Nonnull Collection<DOMRpcIdentifier> rpcs);
+ void onRpcUnavailable(@NonNull Collection<DOMRpcIdentifier> rpcs);
/**
* Implementation filtering method. This method is useful for forwarding RPC implementations,
package org.opendaylight.mdsal.dom.api;
import com.google.common.util.concurrent.FluentFuture;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
* or report a subclass of {@link DOMRpcException} reporting a transport
* error.
*/
- @Nonnull FluentFuture<DOMRpcResult> invokeRpc(@Nonnull DOMRpcIdentifier rpc, @Nullable NormalizedNode<?, ?> input);
+ // FIXME: 4.0.0: do not allow null input
+ @NonNull FluentFuture<DOMRpcResult> invokeRpc(@NonNull DOMRpcIdentifier rpc, @Nullable NormalizedNode<?, ?> input);
/**
* Return the relative invocation cost of this implementation. Default implementation return 0.
package org.opendaylight.mdsal.dom.api;
import java.util.Set;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
- * A {@link DOMService} which allows registration of RPC implementations with a conceptual
- * router. The client counterpart of this service is {@link DOMRpcService}.
+ * A {@link DOMService} which allows registration of RPC implementations with a conceptual router. The client
+ * counterpart of this service is {@link DOMRpcService}.
*/
public interface DOMRpcProviderService extends DOMService {
/**
* @throws NullPointerException if implementation or types is null
* @throws IllegalArgumentException if types is empty or contains a null element.
*/
- @Nonnull <T extends DOMRpcImplementation> DOMRpcImplementationRegistration<T>
- registerRpcImplementation(@Nonnull T implementation, @Nonnull DOMRpcIdentifier... rpcs);
+ @NonNull <T extends DOMRpcImplementation> DOMRpcImplementationRegistration<T>
+ registerRpcImplementation(@NonNull T implementation, @NonNull DOMRpcIdentifier... rpcs);
/**
* Register an {@link DOMRpcImplementation} object with this service.
* @throws NullPointerException if implementation or types is null
* @throws IllegalArgumentException if types is empty or contains a null element.
*/
- @Nonnull <T extends DOMRpcImplementation> DOMRpcImplementationRegistration<T>
- registerRpcImplementation(@Nonnull T implementation, @Nonnull Set<DOMRpcIdentifier> rpcs);
+ @NonNull <T extends DOMRpcImplementation> DOMRpcImplementationRegistration<T>
+ registerRpcImplementation(@NonNull T implementation, @NonNull Set<DOMRpcIdentifier> rpcs);
}
package org.opendaylight.mdsal.dom.api;
import com.google.common.util.concurrent.FluentFuture;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
*
* @param type SchemaPath of the RPC to be invoked
* @param input Input arguments, null if the RPC does not take any.
- * @return A {@link FluentFuture} which will return either a result structure,
- * or report a subclass of {@link DOMRpcException} reporting a transport
- * error.
+ * @return A {@link FluentFuture} which will return either a result structure, or report a subclass
+ * of {@link DOMRpcException} reporting a transport error.
*/
- @Nonnull FluentFuture<DOMRpcResult> invokeRpc(@Nonnull SchemaPath type, @Nullable NormalizedNode<?, ?> input);
+ // FIXME: 4.0.0: do not allow null input
+ @NonNull FluentFuture<DOMRpcResult> invokeRpc(@NonNull SchemaPath type, @Nullable NormalizedNode<?, ?> input);
/**
* Register a {@link DOMRpcAvailabilityListener} with this service to receive notifications
*
* @param listener {@link DOMRpcAvailabilityListener} instance to register
* @return A {@link ListenerRegistration} representing this registration. Performing a
- * {@link ListenerRegistration#close()} will cancel it. Returned object is guaranteed to
- * be non-null.
+ * {@link ListenerRegistration#close()} will cancel it. Returned object is guaranteed to be non-null.
*/
- @Nonnull <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(@Nonnull T listener);
+ @NonNull <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(@NonNull T listener);
}
import java.net.URI;
import java.util.Collections;
import java.util.concurrent.ExecutionException;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.junit.Test;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeCursorAwareTransaction;
*
* @return {@link DOMDataTreeService} instance.
*/
- protected abstract @Nonnull DOMDataTreeService service();
+ protected abstract @NonNull DOMDataTreeService service();
/**
* A simple unbound producer. It write some basic things into the data store based on the
Code Review / mdsal.git / commitdiff