import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.StampedLock;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
/**
* @param path Path to find a node for
* @return A registration node for the specified path
*/
- @Nonnull protected final RegistrationTreeNode<T> findNodeFor(@Nonnull final Iterable<PathArgument> path) {
+ protected final @NonNull RegistrationTreeNode<T> findNodeFor(final @NonNull Iterable<PathArgument> path) {
RegistrationTreeNode<T> walkNode = rootNode;
for (final PathArgument arg : path) {
walkNode = walkNode.ensureChild(arg);
* @param node Tree node
* @param registration Registration instance
*/
- protected final void addRegistration(@Nonnull final RegistrationTreeNode<T> node, @Nonnull final T registration) {
+ protected final void addRegistration(final @NonNull RegistrationTreeNode<T> node, final @NonNull T registration) {
node.addRegistration(registration);
}
* @param node Tree node
* @param registration Registration instance
*/
- protected final void removeRegistration(@Nonnull final RegistrationTreeNode<T> node,
- @Nonnull final T registration) {
+ protected final void removeRegistration(final @NonNull RegistrationTreeNode<T> node,
+ final @NonNull T registration) {
// Take the write lock
writeLock.lock();
try {
*
* @return A snapshot instance.
*/
- @Nonnull public final RegistrationTreeSnapshot<T> takeSnapshot() {
+ public final @NonNull RegistrationTreeSnapshot<T> takeSnapshot() {
readLock.lock();
return new RegistrationTreeSnapshot<>(readLock, rootNode);
}
import com.google.common.annotations.Beta;
import java.util.EnumMap;
import java.util.Map;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
import javax.annotation.concurrent.NotThreadSafe;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.slf4j.Logger;
* @param prefix Prefix for lookup
* @return closest non-null entry towards root or null if no entry towards root exists.
*/
- @Nullable
- public DOMDataTreePrefixTableEntry<V> lookup(@Nonnull final DOMDataTreeIdentifier prefix) {
+ public @Nullable DOMDataTreePrefixTableEntry<V> lookup(final @NonNull DOMDataTreeIdentifier prefix) {
final DOMDataTreePrefixTableEntry<V> t = roots.get(prefix.getDatastoreType());
- if (t == null) {
- return null;
- }
-
- return t.lookup(prefix.getRootIdentifier());
+ return t == null ? null : t.lookup(prefix.getRootIdentifier());
}
/**
* @param value Value to be stored
* @throws IllegalStateException If value is already stored for provided prefix
*/
- public void store(@Nonnull final DOMDataTreeIdentifier prefix, @Nonnull final V value) {
+ public void store(final @NonNull DOMDataTreeIdentifier prefix, final @NonNull V value) {
DOMDataTreePrefixTableEntry<V> domDataTreePrefixTableEntry = roots.get(prefix.getDatastoreType());
if (domDataTreePrefixTableEntry == null) {
domDataTreePrefixTableEntry = new DOMDataTreePrefixTableEntry<>();
*
* @param prefix to be removed
*/
- public void remove(@Nonnull final DOMDataTreeIdentifier prefix) {
+ public void remove(final @NonNull DOMDataTreeIdentifier prefix) {
final DOMDataTreePrefixTableEntry<V> t = roots.get(prefix.getDatastoreType());
if (t == null) {
LOG.warn("Shard registration {} points to non-existent table", t);
t.remove(prefix.getRootIdentifier());
}
-
}
import java.util.Collection;
import java.util.Collections;
import java.util.Objects;
-import javax.annotation.Nonnull;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
this.errors = requireNonNull(errors);
}
- public DefaultDOMRpcResult(@Nonnull final Collection<RpcError> errors) {
+ public DefaultDOMRpcResult(final Collection<RpcError> errors) {
this(null, errors);
}
import com.google.common.collect.ClassToInstanceMap;
import com.google.common.collect.ForwardingObject;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
public abstract class ForwardingDOMDataBroker extends ForwardingObject implements DOMDataBroker {
@Override
- @Nonnull
- protected abstract DOMDataBroker delegate();
+ protected abstract @NonNull DOMDataBroker delegate();
@Override
public DOMDataTreeReadTransaction newReadOnlyTransaction() {
import com.google.common.collect.ForwardingObject;
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.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public abstract class ForwardingDOMDataReadOnlyTransaction extends ForwardingObject
implements DOMDataTreeReadTransaction {
@Override
- @Nonnull
- protected abstract DOMDataTreeReadTransaction delegate();
+ protected abstract @NonNull DOMDataTreeReadTransaction delegate();
@Override
public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
import com.google.common.collect.ForwardingObject;
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.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
public abstract class ForwardingDOMDataReadWriteTransaction extends ForwardingObject
implements DOMDataTreeReadWriteTransaction {
@Override
- @Nonnull
- protected abstract DOMDataTreeReadWriteTransaction delegate();
+ protected abstract @NonNull DOMDataTreeReadWriteTransaction delegate();
@Override
public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
import com.google.common.collect.ForwardingObject;
import com.google.common.util.concurrent.FluentFuture;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
public abstract class ForwardingDOMDataWriteTransaction extends ForwardingObject
implements DOMDataTreeWriteTransaction {
@Override
- @Nonnull
- protected abstract DOMDataTreeWriteTransaction delegate();
+ protected abstract @NonNull DOMDataTreeWriteTransaction delegate();
@Override
public Object getIdentifier() {
import com.google.common.collect.ForwardingObject;
import com.google.common.util.concurrent.FluentFuture;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
*/
public abstract class ForwardingDOMRpcImplementation extends ForwardingObject implements DOMRpcImplementation {
@Override
- @Nonnull
- protected abstract DOMRpcImplementation delegate();
+ protected abstract @NonNull DOMRpcImplementation delegate();
@Override
public FluentFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier type, final NormalizedNode<?, ?> input) {
import com.google.common.collect.ForwardingObject;
import java.util.Set;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementationRegistration;
*/
public abstract class ForwardingDOMRpcProviderService extends ForwardingObject implements DOMRpcProviderService {
@Override
- @Nonnull
- protected abstract DOMRpcProviderService delegate();
+ protected abstract @NonNull DOMRpcProviderService delegate();
@Override
public <T extends DOMRpcImplementation> DOMRpcImplementationRegistration<T> registerRpcImplementation(
import com.google.common.collect.ForwardingObject;
import com.google.common.util.concurrent.FluentFuture;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
*/
public abstract class ForwardingDOMRpcService extends ForwardingObject implements DOMRpcService {
@Override
- @Nonnull
- protected abstract DOMRpcService delegate();
+ protected abstract @NonNull DOMRpcService delegate();
@Override
public FluentFuture<DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
package org.opendaylight.mdsal.dom.spi;
import com.google.common.collect.ForwardingObject;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
*/
public abstract class ForwardingDOMTransactionChain extends ForwardingObject implements DOMTransactionChain {
@Override
- @Nonnull
- protected abstract DOMTransactionChain delegate();
+ protected abstract @NonNull DOMTransactionChain delegate();
@Override
public void close() {
import com.google.common.annotations.Beta;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.mdsal.dom.api.DOMDataTreeListener;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
*/
@Beta
public interface DOMDataTreeListenerRegistry {
-
- @Nonnull <T extends DOMDataTreeListener> ListenerRegistration<T> registerListener(@Nonnull T listener,
- @Nonnull Collection<DOMDataTreeIdentifier> subtrees, boolean allowRxMerges);
+ <T extends DOMDataTreeListener> @NonNull ListenerRegistration<T> registerListener(@NonNull T listener,
+ @NonNull Collection<DOMDataTreeIdentifier> subtrees, boolean allowRxMerges);
}
import com.google.common.annotations.Beta;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
@Beta
*
* @return Collection of data tree identifiers.
*/
- @Nonnull Collection<DOMDataTreeIdentifier> getPrefixes();
+ @NonNull Collection<DOMDataTreeIdentifier> getPrefixes();
/**
* Create a new write transaction for this producer. Any previous transactions need to be closed either via
* @return A new write transaction
* @throws IllegalStateException if a previous transaction has not been closed
*/
- DOMDataTreeShardWriteTransaction createTransaction();
+ @NonNull DOMDataTreeShardWriteTransaction createTransaction();
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.mdsal.dom.spi.shard;
import com.google.common.annotations.Beta;
import com.google.common.util.concurrent.ListenableFuture;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMDataTreeCursorProvider;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteCursor;
* @throws NullPointerException if prefix is null.
*/
@Override
- @Nonnull DOMDataTreeWriteCursor createCursor(@Nonnull DOMDataTreeIdentifier prefix);
+ // FIXME: 4.0.0: reconcile @NonNull vs. super @Nullable
+ @NonNull DOMDataTreeWriteCursor createCursor(@NonNull DOMDataTreeIdentifier prefix);
/**
* Finish this transaction and submit it for processing.
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.mdsal.dom.spi.shard;
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.mdsal.dom.api.DOMDataTreeWriteCursor;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
*
* @return null if requested child is not subshard or enclosing node of any subshard.
*/
- @Nullable public abstract WriteableModificationNode getChild(@Nonnull PathArgument node);
+ public abstract @Nullable WriteableModificationNode getChild(@NonNull PathArgument node);
public abstract Map<PathArgument, WriteableModificationNode> getChildrenWithSubshards();
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
import org.opendaylight.mdsal.dom.spi.AbstractDOMDataTreeChangeListenerRegistration;
import org.opendaylight.mdsal.dom.spi.AbstractRegistrationTree;
* @param registration the registration to notify
* @param changes the list of DataTreeCandidate changes
*/
- protected abstract void notifyListener(@Nonnull AbstractDOMDataTreeChangeListenerRegistration<?> registration,
- @Nonnull Collection<DataTreeCandidate> changes);
+ protected abstract void notifyListener(@NonNull AbstractDOMDataTreeChangeListenerRegistration<?> registration,
+ @NonNull Collection<DataTreeCandidate> changes);
/**
* Callback notifying the subclass that the specified registration is being
* @param registration Registration which is being closed
*/
protected abstract void registrationRemoved(
- @Nonnull AbstractDOMDataTreeChangeListenerRegistration<?> registration);
+ @NonNull AbstractDOMDataTreeChangeListenerRegistration<?> registration);
/**
* Process a candidate tree with respect to registered listeners.
*
* @param candidate candidate three which needs to be processed
*/
- protected final void processCandidateTree(@Nonnull final DataTreeCandidate candidate) {
+ protected final void processCandidateTree(final @NonNull DataTreeCandidate candidate) {
final DataTreeCandidateNode node = candidate.getRootNode();
if (node.getModificationType() == ModificationType.UNMODIFIED) {
LOG.debug("Skipping unmodified candidate {}", candidate);
*/
package org.opendaylight.mdsal.dom.spi.store;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
* notifications. This is especially true in OSGi environments, where failure to
* do so during bundle shutdown can lead to stale listeners being still registered.
*
- * @param treeId
- * Data tree identifier of the subtree which should be watched for
- * changes.
- * @param listener
- * Listener instance which is being registered
- * @return Listener registration object, which may be used to unregister
- * your listener using {@link ListenerRegistration#close()} to stop
- * delivery of change events.
+ * @param treeId Data tree identifier of the subtree which should be watched for changes.
+ * @param listener Listener instance which is being registered
+ * @return Listener registration object, which may be used to unregister your listener using
+ * {@link ListenerRegistration#close()} to stop delivery of change events.
*/
- @Nonnull
- <L extends DOMDataTreeChangeListener> ListenerRegistration<L> registerTreeChangeListener(
- @Nonnull YangInstanceIdentifier treeId, @Nonnull L listener);
+ <L extends DOMDataTreeChangeListener> @NonNull ListenerRegistration<L> registerTreeChangeListener(
+ @NonNull YangInstanceIdentifier treeId, @NonNull L listener);
}
import com.google.common.base.Throwables;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
package org.opendaylight.mdsal.dom.spi;
import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
import static org.mockito.MockitoAnnotations.initMocks;
import java.util.Set;
-import javax.annotation.Nonnull;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
@Test
public void registerRpcImplementation() throws Exception {
initMocks(this);
- assertEquals(domRpcImplementationRegistration, this.registerRpcImplementation(null));
+ assertEquals(domRpcImplementationRegistration, this.registerRpcImplementation(
+ mock(DOMRpcImplementation.class)));
}
- @Nonnull
@Override
public <T extends DOMRpcImplementation> DOMRpcImplementationRegistration<T> registerRpcImplementation(
- @Nonnull T implementation, @Nonnull Set<DOMRpcIdentifier> rpcs) {
+ final T implementation, final Set<DOMRpcIdentifier> rpcs) {
return domRpcImplementationRegistration;
}
}
\ No newline at end of file
import static org.mockito.MockitoAnnotations.initMocks;
import com.google.common.collect.ImmutableClassToInstanceMap;
-import javax.annotation.Nonnull;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
verify(domDataBroker).newWriteOnlyTransaction();
}
- @Nonnull
@Override
protected DOMDataBroker delegate() {
return domDataBroker;
import static org.mockito.Mockito.verify;
import static org.mockito.MockitoAnnotations.initMocks;
-import javax.annotation.Nonnull;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
verify(domDataTreeReadTransaction).close();
}
- @Nonnull
@Override
protected DOMDataTreeReadTransaction delegate() {
return domDataTreeReadTransaction;
import static org.mockito.Mockito.verify;
import static org.mockito.MockitoAnnotations.initMocks;
-import javax.annotation.Nonnull;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
verify(domDataTreeWriteTransaction).cancel();
}
- @Nonnull
@Override
protected DOMDataTreeWriteTransaction delegate() {
return domDataTreeWriteTransaction;
import static org.mockito.Mockito.verify;
import static org.mockito.MockitoAnnotations.initMocks;
-import javax.annotation.Nonnull;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
verify(domRpcImplementation).invokeRpc(domRpcIdentifier, null);
}
- @Nonnull
@Override
protected DOMRpcImplementation delegate() {
return domRpcImplementation;
import static org.mockito.MockitoAnnotations.initMocks;
import java.util.Collections;
-import javax.annotation.Nonnull;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
verify(domRpcProviderService).registerRpcImplementation(domRpcImplementation, Collections.EMPTY_SET);
}
- @Nonnull
@Override
protected DOMRpcProviderService delegate() {
return domRpcProviderService;
import static org.mockito.Mockito.verify;
import static org.mockito.MockitoAnnotations.initMocks;
-import javax.annotation.Nonnull;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
verify(domRpcResult).getResult();
}
- @Nonnull
@Override
protected DOMRpcResult delegate() {
return domRpcResult;
import static org.mockito.Mockito.verify;
import static org.mockito.MockitoAnnotations.initMocks;
-import javax.annotation.Nonnull;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
verify(domRpcService).registerRpcListener(domRpcAvailabilityListener);
}
- @Nonnull
@Override
protected DOMRpcService delegate() {
return domRpcService;
import static org.mockito.Mockito.verify;
import static org.mockito.MockitoAnnotations.initMocks;
-import javax.annotation.Nonnull;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
verify(domTransactionChain).close();
}
- @Nonnull
@Override
protected DOMTransactionChain delegate() {
return domTransactionChain;
import com.google.common.collect.ImmutableList;
import java.lang.reflect.Field;
import java.util.Collection;
-import javax.annotation.Nonnull;
import org.junit.Assert;
import org.junit.Test;
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
}
@Override
- protected void registrationRemoved(@Nonnull final AbstractDOMDataTreeChangeListenerRegistration<?> registration) {
+ protected void registrationRemoved(final AbstractDOMDataTreeChangeListenerRegistration<?> registration) {
removeInvoked = true;
}
}