Enable spotbugs in mdsal-binding-dom-codec

[mdsal.git] / binding / mdsal-binding-dom-codec / src / main / java / org / opendaylight / mdsal / binding / dom / codec / impl / DataObjectCodecContext.java

diff --git a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/DataObjectCodecContext.java b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/DataObjectCodecContext.java
index fecc06a5ae73f39b86010c8d3e65cd49a22e9796..88731f31cddc14ceeb1a9cb5ea4b7c5a92f60a47 100644 (file)
--- a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/DataObjectCodecContext.java
+++ b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/DataObjectCodecContext.java
@@ -7,11 +7,12 @@
  */
 package org.opendaylight.mdsal.binding.dom.codec.impl;
 
-import com.google.common.base.Optional;
-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 edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
@@ -24,20 +25,22 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Optional;
 import java.util.SortedMap;
 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;
 import org.opendaylight.yangtools.yang.binding.Augmentable;
 import org.opendaylight.yangtools.yang.binding.Augmentation;
 import org.opendaylight.yangtools.yang.binding.AugmentationHolder;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.Item;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
@@ -50,16 +53,17 @@ import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
 import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-abstract class DataObjectCodecContext<D extends DataObject, T extends DataNodeContainer>
+abstract class DataObjectCodecContext<D extends DataObject, T extends DataNodeContainer & WithStatus>
         extends DataContainerCodecContext<D, T> {
     private static final Logger LOG = LoggerFactory.getLogger(DataObjectCodecContext.class);
     private static final MethodType CONSTRUCTOR_TYPE = MethodType.methodType(void.class, InvocationHandler.class);
     private static final MethodType DATAOBJECT_TYPE = MethodType.methodType(DataObject.class, InvocationHandler.class);
-    private static final Comparator<Method> METHOD_BY_ALPHABET = (o1, o2) -> o1.getName().compareTo(o2.getName());
+    private static final Comparator<Method> METHOD_BY_ALPHABET = Comparator.comparing(Method::getName);
 
     private final ImmutableMap<String, LeafNodeCodecContext<?>> leafChild;
     private final ImmutableMap<YangInstanceIdentifier.PathArgument, NodeContextSupplier> byYang;
@@ -127,6 +131,7 @@ abstract class DataObjectCodecContext<D extends DataObject, T extends DataNodeCo
         }
     }
 
+    @SuppressFBWarnings("RV_RETURN_VALUE_OF_PUTIFABSENT_IGNORED")
     private void reloadAllAugmentations() {
         for (final Entry<AugmentationIdentifier, Type> augment : possibleAugmentations.entrySet()) {
             final DataContainerCodecPrototype<?> augProto = getAugmentationPrototype(augment.getValue());
@@ -164,7 +169,7 @@ abstract class DataObjectCodecContext<D extends DataObject, T extends DataNodeCo
         if (childProto != null) {
             return Optional.of((DataContainerCodecContext<C, ?>) childProto.get());
         }
-        return Optional.absent();
+        return Optional.empty();
     }
 
     @Override
@@ -180,8 +185,18 @@ abstract class DataObjectCodecContext<D extends DataObject, T extends DataNodeCo
                 childNonNull(ctxProto, argType, "Class %s is not valid child of %s", argType, getBindingClass()).get();
         if (context instanceof ChoiceNodeCodecContext) {
             final ChoiceNodeCodecContext<?> choice = (ChoiceNodeCodecContext<?>) context;
-            final DataContainerCodecContext<?, ?> caze = choice.getCazeByChildClass(arg.getType());
             choice.addYangPathArgument(arg, builder);
+
+            final java.util.Optional<? extends Class<? extends DataObject>> caseType = arg.getCaseType();
+            final Class<? extends DataObject> type = arg.getType();
+            final DataContainerCodecContext<?, ?> caze;
+            if (caseType.isPresent()) {
+                // Non-ambiguous addressing this should not pose any problems
+                caze = choice.streamChild(caseType.get());
+            } else {
+                caze = choice.getCaseByChildClass(type);
+            }
+
             caze.addYangPathArgument(arg, builder);
             return caze.bindingPathArgumentChild(arg, builder);
         }
@@ -235,7 +250,7 @@ abstract class DataObjectCodecContext<D extends DataObject, T extends DataNodeCo
             }
         } else {
             // We are looking for instantiation via uses in other module
-            final QName instantiedName = QName.create(namespace(), origDef.getQName().getLocalName());
+            final QName instantiedName = origDef.getQName().withModule(namespace());
             final DataSchemaNode potential = getSchema().getDataChildByName(instantiedName);
             // We check if it is really instantiated from same
             // definition as class was derived
@@ -247,7 +262,12 @@ abstract class DataObjectCodecContext<D extends DataObject, T extends DataNodeCo
         }
         final DataSchemaNode nonNullChild =
                 childNonNull(childSchema, childClass, "Node %s does not have child named %s", getSchema(), childClass);
-        return DataContainerCodecPrototype.from(childClass, nonNullChild, factory());
+        return DataContainerCodecPrototype.from(createBindingArg(childClass, nonNullChild), nonNullChild, factory());
+    }
+
+    @SuppressWarnings("unchecked")
+    Item<?> createBindingArg(final Class<?> childClass, final DataSchemaNode childSchema) {
+        return Item.of((Class<? extends DataObject>) childClass);
     }
 
     private DataContainerCodecPrototype<?> yangAugmentationChild(final AugmentationIdentifier arg) {
@@ -262,8 +282,7 @@ abstract class DataObjectCodecContext<D extends DataObject, T extends DataNodeCo
         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;
@@ -272,8 +291,8 @@ abstract class DataObjectCodecContext<D extends DataObject, T extends DataNodeCo
         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;
@@ -372,13 +391,13 @@ abstract class DataObjectCodecContext<D extends DataObject, T extends DataNodeCo
 
     @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();
     }
 }