*/
package org.opendaylight.mdsal.binding.dom.codec.api;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
// TODO: Add more detailed documentation
public interface BindingCodecTree {
- @Nullable
- <T extends DataObject> BindingCodecTreeNode<T> getSubtreeCodec(InstanceIdentifier<T> path);
+ @Nullable <T extends DataObject> BindingCodecTreeNode<T> getSubtreeCodec(InstanceIdentifier<T> path);
- @Nullable
- BindingCodecTreeNode<?> getSubtreeCodec(YangInstanceIdentifier path);
-
- @Nullable
- BindingCodecTreeNode<?> getSubtreeCodec(SchemaPath path);
+ @Nullable BindingCodecTreeNode<?> getSubtreeCodec(YangInstanceIdentifier path);
+ @Nullable BindingCodecTreeNode<?> getSubtreeCodec(SchemaPath path);
}
import com.google.common.collect.ImmutableCollection;
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.yangtools.yang.binding.BindingStreamEventWriter;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
*
* @return interface which defines API of binding representation of data.
*/
- @Nonnull
- Class<T> getBindingClass();
+ @NonNull Class<T> getBindingClass();
/**
* Returns child context as if it was walked by {@link BindingStreamEventWriter}. This means that to enter case,
* @throws IllegalArgumentException
* If supplied child class is not valid in specified context.
*/
- @Nonnull
- <E extends DataObject> BindingCodecTreeNode<E> streamChild(@Nonnull Class<E> childClass);
+ // FIXME: this may return null in some implementations...
+ <E extends DataObject> @NonNull BindingCodecTreeNode<E> streamChild(@NonNull Class<E> childClass);
/**
* Returns child context as if it was walked by {@link BindingStreamEventWriter}. This means that to enter case,
* applicable in context.
*/
<E extends DataObject> Optional<? extends BindingCodecTreeNode<E>> possibleStreamChild(
- @Nonnull Class<E> childClass);
+ @NonNull Class<E> childClass);
/**
* Returns nested node context using supplied YANG Instance Identifier.
* @throws IllegalArgumentException
* If supplied argument does not represent valid child.
*/
- @Nonnull
- BindingCodecTreeNode<?> yangPathArgumentChild(@Nonnull YangInstanceIdentifier.PathArgument child);
+ @NonNull BindingCodecTreeNode<?> yangPathArgumentChild(YangInstanceIdentifier.@NonNull PathArgument child);
/**
* Returns nested node context using supplied Binding Instance Identifier and adds YANG instance identifiers to
* @throws IllegalArgumentException
* If supplied argument does not represent valid child.
*/
- @Nonnull
- BindingCodecTreeNode<?> bindingPathArgumentChild(@Nonnull InstanceIdentifier.PathArgument arg,
+ @NonNull BindingCodecTreeNode<?> bindingPathArgumentChild(InstanceIdentifier.@NonNull PathArgument arg,
@Nullable List<YangInstanceIdentifier.PathArgument> builder);
/**
* @param cacheSpecifier Set of objects, for which cache may be in place
* @return Codec whihc uses cache for serialization / deserialization.
*/
- @Nonnull
- BindingNormalizedNodeCachingCodec<T> createCachingCodec(@Nonnull
- ImmutableCollection<Class<? extends DataObject>> cacheSpecifier);
+ @NonNull BindingNormalizedNodeCachingCodec<T> createCachingCodec(
+ @NonNull ImmutableCollection<Class<? extends DataObject>> cacheSpecifier);
@Beta
void writeAsNormalizedNode(T data, NormalizedNodeStreamWriter writer);
* @throws IllegalArgumentException If supplied {@code arg} is not valid.
*/
@Beta
- @Nullable YangInstanceIdentifier.PathArgument serializePathArgument(@Nullable InstanceIdentifier.PathArgument arg);
+ YangInstanceIdentifier.@Nullable PathArgument serializePathArgument(InstanceIdentifier.@Nullable PathArgument arg);
/**
* Deserializes path argument for current node.
* @throws IllegalArgumentException If supplied {@code arg} is not valid.
*/
@Beta
- @Nullable InstanceIdentifier.PathArgument deserializePathArgument(
- @Nullable YangInstanceIdentifier.PathArgument arg);
+ InstanceIdentifier.@Nullable PathArgument deserializePathArgument(
+ YangInstanceIdentifier.@Nullable PathArgument arg);
/**
* Return the schema node associated with this node.
*
* @return A schema node.
*/
- @Nonnull WithStatus getSchema();
+ @NonNull WithStatus getSchema();
/**
* Return a summary of addressability of potential children. Binding specification does not allow all DOM tree
*
* @return Summary children addressability.
*/
- @Nonnull ChildAddressabilitySummary getChildAddressabilitySummary();
+ @NonNull ChildAddressabilitySummary getChildAddressabilitySummary();
/**
* Enumeration of possible addressability attribute of all children.
package org.opendaylight.mdsal.binding.dom.codec.api;
import com.google.common.annotations.Beta;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
* @param data Normalized Node representation of data
* @return Binding representation of data
*/
- @Nonnull T deserialize(@Nonnull NormalizedNode<?,?> data);
+ @NonNull T deserialize(@NonNull NormalizedNode<?,?> data);
/**
* Converts from Binding to Normalized Node representation of data.
* @param data Binding representation of data
* @return Normalized Node representation of data
*/
- @Nonnull NormalizedNode<?,?> serialize(@Nonnull T data);
-
+ @NonNull NormalizedNode<?,?> serialize(@NonNull T data);
}
import com.google.common.annotations.Beta;
import java.util.Map.Entry;
-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.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.yang.binding.Action;
import org.opendaylight.yangtools.yang.binding.DataContainer;
* @return DOM Instance Identifier
* @throws IllegalArgumentException If supplied Instance Identifier is not valid.
*/
- YangInstanceIdentifier toYangInstanceIdentifier(@Nonnull InstanceIdentifier<?> binding);
+ YangInstanceIdentifier toYangInstanceIdentifier(@NonNull InstanceIdentifier<?> binding);
/**
* Translates supplied YANG Instance Identifier into Binding instance identifier.
* @param dom YANG Instance Identifier
* @return Binding Instance Identifier, or null if the instance identifier is not representable.
*/
- @Nullable
- <T extends DataObject> InstanceIdentifier<T> fromYangInstanceIdentifier(@Nonnull YangInstanceIdentifier dom);
+ <T extends DataObject> @Nullable InstanceIdentifier<T> fromYangInstanceIdentifier(
+ @NonNull YangInstanceIdentifier dom);
/**
* Translates supplied Binding Instance Identifier and data into NormalizedNode representation.
* @param data NormalizedNode representing data
* @return DOM Instance Identifier
*/
- @Nullable
- Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(@Nonnull YangInstanceIdentifier path,
+ @Nullable Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(@NonNull YangInstanceIdentifier path,
NormalizedNode<?, ?> data);
/**
* @param data NormalizedNode representing data
* @return Binding representation of Notification
*/
- @Nullable Notification fromNormalizedNodeNotification(@Nonnull SchemaPath path,@Nonnull ContainerNode data);
+ @Nullable Notification fromNormalizedNodeNotification(@NonNull SchemaPath path, @NonNull ContainerNode data);
/**
* Translates supplied NormalizedNode RPC input or output into Binding data.
* @param data NormalizedNode representing data
* @return Binding representation of RPC data
*/
- @Nullable DataObject fromNormalizedNodeRpcData(@Nonnull SchemaPath path,@Nonnull ContainerNode data);
+ @Nullable DataObject fromNormalizedNodeRpcData(@NonNull SchemaPath path, @NonNull ContainerNode data);
/**
* Translates supplied ContainerNode action input.
* @param data NormalizedNode representing notification data
* @return NormalizedNode representation of notification
*/
- @Nonnull ContainerNode toNormalizedNodeNotification(@Nonnull Notification data);
+ @NonNull ContainerNode toNormalizedNodeNotification(@NonNull Notification data);
/**
* Translates supplied Binding RPC input or output into NormalizedNode data.
* @param data NormalizedNode representing rpc data
* @return NormalizedNode representation of rpc data
*/
- @Nonnull ContainerNode toNormalizedNodeRpcData(@Nonnull DataContainer data);
+ @NonNull ContainerNode toNormalizedNodeRpcData(@NonNull DataContainer data);
/**
* Lazily translates supplied Binding action input into NormalizedNode data.
package org.opendaylight.mdsal.binding.dom.codec.api;
import java.util.Map.Entry;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.binding.Action;
import org.opendaylight.yangtools.yang.binding.BindingStreamEventWriter;
import org.opendaylight.yangtools.yang.binding.DataContainer;
* which will write to supplied {@link NormalizedNodeStreamWriter}.
* @throws IllegalArgumentException If supplied Instance Identifier is not valid.
*/
- @Nonnull Entry<YangInstanceIdentifier, BindingStreamEventWriter> newWriterAndIdentifier(
- @Nonnull InstanceIdentifier<?> path, @Nonnull NormalizedNodeStreamWriter domWriter);
+ @NonNull Entry<YangInstanceIdentifier, BindingStreamEventWriter> newWriterAndIdentifier(
+ @NonNull InstanceIdentifier<?> path, @NonNull NormalizedNodeStreamWriter domWriter);
/**
* Creates a {@link BindingStreamEventWriter} for data tree path which will translate to NormalizedNode model
* which will write to supplied {@link NormalizedNodeStreamWriter}.
* @throws IllegalArgumentException If supplied Instance Identifier is not valid.
*/
- @Nonnull
- BindingStreamEventWriter newWriter(@Nonnull InstanceIdentifier<?> path,
- @Nonnull NormalizedNodeStreamWriter domWriter);
+ @NonNull BindingStreamEventWriter newWriter(@NonNull InstanceIdentifier<?> path,
+ @NonNull NormalizedNodeStreamWriter domWriter);
/**
* Creates a {@link BindingStreamEventWriter} for RPC data which will translate to NormalizedNode model and invoke
* @return {@link BindingStreamEventWriter} which will write to supplied
* {@link NormalizedNodeStreamWriter}.
*/
- @Nonnull
- BindingStreamEventWriter newRpcWriter(@Nonnull Class<? extends DataContainer> rpcInputOrOutput,
- @Nonnull NormalizedNodeStreamWriter domWriter);
+ @NonNull BindingStreamEventWriter newRpcWriter(@NonNull Class<? extends DataContainer> rpcInputOrOutput,
+ @NonNull NormalizedNodeStreamWriter domWriter);
/**
* Creates a {@link BindingStreamEventWriter} for notification which will translate to NormalizedNode model
* @return {@link BindingStreamEventWriter} which will write to supplied
* {@link NormalizedNodeStreamWriter}.
*/
- @Nonnull
- BindingStreamEventWriter newNotificationWriter(@Nonnull Class<? extends Notification> notification,
- @Nonnull NormalizedNodeStreamWriter domWriter);
+ @NonNull BindingStreamEventWriter newNotificationWriter(@NonNull Class<? extends Notification> notification,
+ @NonNull NormalizedNodeStreamWriter domWriter);
/**
* Creates a {@link BindingStreamEventWriter} for action input which will translate to NormalizedNode model
* @param domWriter Stream writer on which events will be invoked.
* @return {@link BindingStreamEventWriter} which will write to supplied {@link NormalizedNodeStreamWriter}.
*/
- @Nonnull
- BindingStreamEventWriter newActionInputWriter(@Nonnull Class<? extends Action<?, ?, ?>> action,
- @Nonnull NormalizedNodeStreamWriter domWriter);
+ @NonNull BindingStreamEventWriter newActionInputWriter(@NonNull Class<? extends Action<?, ?, ?>> action,
+ @NonNull NormalizedNodeStreamWriter domWriter);
/**
* Creates a {@link BindingStreamEventWriter} for action output which will translate to NormalizedNode model
* @param domWriter Stream writer on which events will be invoked.
* @return {@link BindingStreamEventWriter} which will write to supplied {@link NormalizedNodeStreamWriter}.
*/
- @Nonnull
- BindingStreamEventWriter newActionOutputWriter(@Nonnull Class<? extends Action<?, ?, ?>> action,
- @Nonnull NormalizedNodeStreamWriter domWriter);
+ @NonNull BindingStreamEventWriter newActionOutputWriter(@NonNull Class<? extends Action<?, ?, ?>> action,
+ @NonNull NormalizedNodeStreamWriter domWriter);
}
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.Callable;
-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.dom.codec.api.BindingCodecTree;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeNode;
import org.opendaylight.mdsal.binding.dom.codec.impl.NodeCodecContext.CodecContextFactory;
* binding representation (choice, case, leaf).
*
*/
- @Nullable NodeCodecContext<?> getCodecContextNode(final @Nonnull YangInstanceIdentifier dom,
+ @Nullable NodeCodecContext<?> getCodecContextNode(final @NonNull YangInstanceIdentifier dom,
final @Nullable Collection<InstanceIdentifier.PathArgument> bindingArguments) {
NodeCodecContext<?> currentNode = root;
ListNodeCodecContext<?> currentList = null;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
@SuppressWarnings("unchecked")
@Override
- @Nullable
public D deserialize(final NormalizedNode<?, ?> data) {
Preconditions.checkArgument(data instanceof ChoiceNode);
final NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>> casted =
final NormalizedNode<?, ?> first = Iterables.getFirst(casted.getValue(), null);
if (first == null) {
+ // FIXME: this needs to be sorted out
return null;
}
final DataContainerCodecPrototype<?> caze = byYangCaseChild.get(first.getIdentifier());
return getDomPathArgument();
}
- DataContainerCodecContext<?, ?> getCaseByChildClass(final @Nonnull Class<? extends DataObject> type) {
+ DataContainerCodecContext<?, ?> getCaseByChildClass(final @NonNull Class<? extends DataObject> type) {
DataContainerCodecPrototype<?> result = byCaseChildClass.get(type);
if (result == null) {
// We have not found an unambiguous result, try ambiguous ones
import java.io.IOException;
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.mdsal.binding.dom.codec.api.BindingNormalizedNodeCachingCodec;
import org.opendaylight.yangtools.yang.binding.BindingStreamEventWriter;
import org.opendaylight.yangtools.yang.binding.DataObject;
* @throws IllegalArgumentException If supplied argument does not represent valid child.
*/
@Override
- @Nullable
public DataContainerCodecContext<?,?> bindingPathArgumentChild(final PathArgument arg,
final List<YangInstanceIdentifier.PathArgument> builder) {
final DataContainerCodecContext<?,?> child = streamChild(arg.getType());
* @throws IllegalArgumentException If supplied child class is not valid in specified context.
*/
@Override
- public abstract @Nullable <C extends DataObject> DataContainerCodecContext<C, ?> streamChild(Class<C> childClass);
+ public abstract <C extends DataObject> DataContainerCodecContext<C, ?> streamChild(Class<C> childClass);
/**
* Returns child context as if it was walked by {@link BindingStreamEventWriter}. This means that to enter case, one
return BindingToNormalizedStreamWriter.create(this, domWriter);
}
- @Nonnull
- protected final <V> V childNonNull(@Nullable final V nullable, final YangInstanceIdentifier.PathArgument child,
- final String message, final Object... args) {
+ protected final <V> @NonNull V childNonNull(final @Nullable V nullable,
+ final YangInstanceIdentifier.PathArgument child, final String message, final Object... args) {
if (nullable != null) {
return nullable;
}
throw IncorrectNestingException.create(message, args);
}
- @Nonnull
- protected final <V> V childNonNull(@Nullable final V nullable, final QName child, final String message,
+ protected final <V> @NonNull V childNonNull(final @Nullable V nullable, final QName child, final String message,
final Object... args) {
if (nullable != null) {
return nullable;
throw IncorrectNestingException.create(message, args);
}
- @Nonnull
- protected final <V> V childNonNull(@Nullable final V nullable, final Class<?> childClass, final String message,
- final Object... args) {
+ protected final <V> @NonNull V childNonNull(final @Nullable V nullable, final Class<?> childClass,
+ final String message, final Object... args) {
if (nullable != null) {
return nullable;
}
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSortedMap;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-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.generator.api.ClassLoadingStrategy;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
return null;
}
- @Nullable
- private DataContainerCodecPrototype<?> augmentationByClass(@Nonnull final Class<?> childClass) {
+ private @Nullable DataContainerCodecPrototype<?> augmentationByClass(final @NonNull Class<?> childClass) {
final DataContainerCodecPrototype<?> firstTry = augmentationByClassOrEquivalentClass(childClass);
if (firstTry != null) {
return firstTry;
return augmentationByClassOrEquivalentClass(childClass);
}
- @Nullable
- private DataContainerCodecPrototype<?> augmentationByClassOrEquivalentClass(@Nonnull final Class<?> childClass) {
+ private @Nullable DataContainerCodecPrototype<?> augmentationByClassOrEquivalentClass(
+ final @NonNull Class<?> childClass) {
final DataContainerCodecPrototype<?> childProto = byStreamAugmented.get(childClass);
if (childProto != null) {
return childProto;
@Override
public InstanceIdentifier.PathArgument deserializePathArgument(final YangInstanceIdentifier.PathArgument arg) {
- Preconditions.checkArgument(getDomPathArgument().equals(arg));
+ checkArgument(getDomPathArgument().equals(arg));
return bindingArg();
}
@Override
public YangInstanceIdentifier.PathArgument serializePathArgument(final InstanceIdentifier.PathArgument arg) {
- Preconditions.checkArgument(bindingArg().equals(arg));
+ checkArgument(bindingArg().equals(arg));
return getDomPathArgument();
}
}
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
/**
* Thrown where incorrect nesting of data structures was detected and was caused by user.
}
}
- @Nonnull
- public static <V> V checkNonNull(@Nullable final V nullable, final String message, final Object... args) {
+ public static <V> @NonNull V checkNonNull(final @Nullable V nullable, final String message, final Object... args) {
if (nullable != null) {
return nullable;
}
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableCollection;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.Set;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeNode;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeCachingCodec;
import org.opendaylight.yangtools.concepts.Codec;
LeafNodeCodecContext(final DataSchemaNode schema, final Codec<Object, Object> codec, final Method getter,
final SchemaContext schemaContext) {
this.yangIdentifier = new YangInstanceIdentifier.NodeIdentifier(schema.getQName());
- this.valueCodec = Preconditions.checkNotNull(codec);
+ this.valueCodec = requireNonNull(codec);
this.getter = getter;
- this.schema = Preconditions.checkNotNull(schema);
+ this.schema = requireNonNull(schema);
this.defaultObject = createDefaultObject(schema, valueCodec, schemaContext);
}
@Override
public InstanceIdentifier.PathArgument deserializePathArgument(final YangInstanceIdentifier.PathArgument arg) {
- Preconditions.checkArgument(getDomPathArgument().equals(arg));
+ checkArgument(getDomPathArgument().equals(arg));
return null;
}
package org.opendaylight.mdsal.binding.dom.codec.impl;
import java.util.function.Supplier;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* Type capture of an entity producing NodeCodecContexts.
*/
interface NodeContextSupplier extends Supplier<NodeCodecContext<?>> {
@Override
- @Nonnull NodeCodecContext<?> get();
+ @NonNull NodeCodecContext<?> get();
}
@Override
public DataContainerCodecContext<?, ?> bindingPathArgumentChild(final InstanceIdentifier.PathArgument arg,
final List<PathArgument> builder) {
- final java.util.Optional<? extends Class<? extends DataObject>> caseType = arg.getCaseType();
+ final Optional<? extends Class<? extends DataObject>> caseType = arg.getCaseType();
if (caseType.isPresent()) {
- final Class<? extends DataObject> type = caseType.get();
- final ChoiceNodeCodecContext<?> choice = choicesByClass.getUnchecked(type);
+ // XXX: we use two caseType.get()s because of https://bugs.openjdk.java.net/browse/JDK-8144185,
+ // which makes JaCoCo blow up if we try using @NonNull on the local variable.
+ final ChoiceNodeCodecContext<?> choice = choicesByClass.getUnchecked(caseType.get());
choice.addYangPathArgument(arg, builder);
- final DataContainerCodecContext<?, ?> caze = choice.streamChild(type);
+ final DataContainerCodecContext<?, ?> caze = choice.streamChild(caseType.get());
caze.addYangPathArgument(arg, builder);
return caze.bindingPathArgumentChild(arg, builder);
}
Code Review / mdsal.git / commitdiff