Fix raw type warnings

Fixes NodeWithValue and similar raw type warnings. Also imports
YangInstanceIdentifier inner interfaces for more readable code.

Change-Id: Iaff9e250fff26b0da70dd9f24d7ccc72121630e4
Signed-off-by: Robert Varga <rovarga@cisco.com>

diff --git a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/DefaultConfigParamsImpl.java b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/DefaultConfigParamsImpl.java
index 46949da17e445d3e63345b47b1f7a74de1baf7c3..f5f410c75b5f6117bd1f3fea6371d521a971517a 100644 (file)
--- a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/DefaultConfigParamsImpl.java
+++ b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/DefaultConfigParamsImpl.java
@@ -173,7 +173,7 @@ public class DefaultConfigParamsImpl implements ConfigParams {
             try {
                 String className = DefaultConfigParamsImpl.this.customRaftPolicyImplementationClass;
                 LOG.info("Trying to use custom RaftPolicy {}", className);
             try {
                 String className = DefaultConfigParamsImpl.this.customRaftPolicyImplementationClass;
                 LOG.info("Trying to use custom RaftPolicy {}", className);

-                Class c = Class.forName(className);
+                Class<?> c = Class.forName(className);

                 RaftPolicy obj = (RaftPolicy)c.newInstance();
                 return obj;
             } catch (Exception e) {
                 RaftPolicy obj = (RaftPolicy)c.newInstance();
                 return obj;
             } catch (Exception e) {

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/NodeIdentifierWithValueGenerator.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/NodeIdentifierWithValueGenerator.java
index bf94a09e56142d1e350166ddd76c21b25e65f63f..9dce97f9aae4341933b16b5fc4c5959987e09d49 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/NodeIdentifierWithValueGenerator.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/NodeIdentifierWithValueGenerator.java
@@ -38,7 +38,7 @@ public class NodeIdentifierWithValueGenerator{
             final String name = matcher.group(1);
             final String value = matcher.group(2);
 
             final String name = matcher.group(1);
             final String value = matcher.group(2);
 

-            return new YangInstanceIdentifier.NodeWithValue(
+            return new YangInstanceIdentifier.NodeWithValue<>(

                 QNameFactory.create(name), getValue(value));
         }
 
                 QNameFactory.create(name), getValue(value));
         }
 

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/PathUtils.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/PathUtils.java
index 2342bf88e9a1c81e78fd8915bce82878762c70e5..8324b64aaac7821683c04589016072831975903c 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/PathUtils.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/PathUtils.java
@@ -15,6 +15,11 @@ import java.util.List;
 import java.util.Set;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import java.util.Set;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;

+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;

 
 public class PathUtils {
     private static final Splitter SLASH_SPLITTER = Splitter.on('/').omitEmptyStrings();
 
 public class PathUtils {
     private static final Splitter SLASH_SPLITTER = Splitter.on('/').omitEmptyStrings();


@@ -27,8 +32,7 @@ public class PathUtils {
      * @return
      */
     public static String toString(YangInstanceIdentifier path) {
      * @return
      */
     public static String toString(YangInstanceIdentifier path) {

-        final Iterator<YangInstanceIdentifier.PathArgument> it =
-            path.getPathArguments().iterator();
+        final Iterator<PathArgument> it = path.getPathArguments().iterator();

         if (!it.hasNext()) {
             return "";
         }
         if (!it.hasNext()) {
             return "";
         }


@@ -52,15 +56,15 @@ public class PathUtils {
      * @param pathArgument
      * @return
      */
      * @param pathArgument
      * @return
      */

-    public static String toString(YangInstanceIdentifier.PathArgument pathArgument){
-        if(pathArgument instanceof YangInstanceIdentifier.NodeIdentifier){
-            return toString((YangInstanceIdentifier.NodeIdentifier) pathArgument);
-        } else if(pathArgument instanceof YangInstanceIdentifier.AugmentationIdentifier){
-            return toString((YangInstanceIdentifier.AugmentationIdentifier) pathArgument);
-        } else if(pathArgument instanceof YangInstanceIdentifier.NodeWithValue){
-            return toString((YangInstanceIdentifier.NodeWithValue) pathArgument);
-        } else if(pathArgument instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates){
-            return toString((YangInstanceIdentifier.NodeIdentifierWithPredicates) pathArgument);
+    public static String toString(PathArgument pathArgument){
+        if(pathArgument instanceof NodeIdentifier){
+            return toString((NodeIdentifier) pathArgument);
+        } else if(pathArgument instanceof AugmentationIdentifier){
+            return toString((AugmentationIdentifier) pathArgument);
+        } else if(pathArgument instanceof NodeWithValue){
+            return toString((NodeWithValue<?>) pathArgument);
+        } else if(pathArgument instanceof NodeIdentifierWithPredicates){
+            return toString((NodeIdentifierWithPredicates) pathArgument);

         }
 
         return pathArgument.toString();
         }
 
         return pathArgument.toString();


@@ -74,18 +78,18 @@ public class PathUtils {
      * @return
      */
     public static YangInstanceIdentifier toYangInstanceIdentifier(String path){
      * @return
      */
     public static YangInstanceIdentifier toYangInstanceIdentifier(String path){

-        List<YangInstanceIdentifier.PathArgument> pathArguments = new ArrayList<>();
+        List<PathArgument> pathArguments = new ArrayList<>();

         for (String segment : SLASH_SPLITTER.split(path)) {
             pathArguments.add(NodeIdentifierFactory.getArgument(segment));
         }
         return YangInstanceIdentifier.create(pathArguments);
     }
 
         for (String segment : SLASH_SPLITTER.split(path)) {
             pathArguments.add(NodeIdentifierFactory.getArgument(segment));
         }
         return YangInstanceIdentifier.create(pathArguments);
     }
 

-    private static String toString(YangInstanceIdentifier.NodeIdentifier pathArgument){
+    private static String toString(NodeIdentifier pathArgument){

         return pathArgument.getNodeType().toString();
     }
 
         return pathArgument.getNodeType().toString();
     }
 

-    private static String toString(YangInstanceIdentifier.AugmentationIdentifier pathArgument){
+    private static String toString(AugmentationIdentifier pathArgument){

         Set<QName> childNames = pathArgument.getPossibleChildNames();
         final StringBuilder sb = new StringBuilder("AugmentationIdentifier{");
         sb.append("childNames=").append(childNames).append('}');
         Set<QName> childNames = pathArgument.getPossibleChildNames();
         final StringBuilder sb = new StringBuilder("AugmentationIdentifier{");
         sb.append("childNames=").append(childNames).append('}');


@@ -93,11 +97,11 @@ public class PathUtils {
 
     }
 
 
     }
 

-    private static String toString(YangInstanceIdentifier.NodeWithValue pathArgument){
+    private static String toString(NodeWithValue<?> pathArgument) {

         return pathArgument.getNodeType().toString() + "[" + pathArgument.getValue() + "]";
     }
 
         return pathArgument.getNodeType().toString() + "[" + pathArgument.getValue() + "]";
     }
 

-    private static String toString(YangInstanceIdentifier.NodeIdentifierWithPredicates pathArgument){
+    private static String toString(NodeIdentifierWithPredicates pathArgument){

         return pathArgument.getNodeType().toString() + '[' + pathArgument.getKeyValues() + ']';
     }
 
         return pathArgument.getNodeType().toString() + '[' + pathArgument.getKeyValues() + ']';
     }
 

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeSerializer.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeSerializer.java
index 9e753800d0eac9f17ab21176e05b3e9b1e59ece6..67c8c439f3102b4b5e25bca6c79def205ac357d4 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeSerializer.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeSerializer.java
@@ -83,12 +83,12 @@ public class NormalizedNodeSerializer {
      * @param node
      * @return
      */
      * @param node
      * @return
      */

-    public static NormalizedNodeMessages.Node serialize(NormalizedNode<?, ?> node){
+    public static NormalizedNodeMessages.Node serialize(final NormalizedNode<?, ?> node){

         Preconditions.checkNotNull(node, "node should not be null");
         return new Serializer(node).serialize();
     }
 
         Preconditions.checkNotNull(node, "node should not be null");
         return new Serializer(node).serialize();
     }
 

-    public static Serializer newSerializer(NormalizedNode<?, ?> node) {
+    public static Serializer newSerializer(final NormalizedNode<?, ?> node) {

         Preconditions.checkNotNull(node, "node should not be null");
         return new Serializer(node);
     }
         Preconditions.checkNotNull(node, "node should not be null");
         return new Serializer(node);
     }


@@ -99,13 +99,13 @@ public class NormalizedNodeSerializer {
      * @param node
      * @return
      */
      * @param node
      * @return
      */

-    public static NormalizedNode<?, ?> deSerialize(NormalizedNodeMessages.Node node) {
+    public static NormalizedNode<?, ?> deSerialize(final NormalizedNodeMessages.Node node) {

         Preconditions.checkNotNull(node, "node should not be null");
         return new DeSerializer(null, node).deSerialize();
     }
 
         Preconditions.checkNotNull(node, "node should not be null");
         return new DeSerializer(null, node).deSerialize();
     }
 

-    public static DeSerializer newDeSerializer(NormalizedNodeMessages.InstanceIdentifier path,
-            NormalizedNodeMessages.Node node) {
+    public static DeSerializer newDeSerializer(final NormalizedNodeMessages.InstanceIdentifier path,
+            final NormalizedNodeMessages.Node node) {

         Preconditions.checkNotNull(node, "node should not be null");
         return new DeSerializer(path, node);
     }
         Preconditions.checkNotNull(node, "node should not be null");
         return new DeSerializer(path, node);
     }


@@ -123,8 +123,8 @@ public class NormalizedNodeSerializer {
      * @param pathArgument
      * @return
      */
      * @param pathArgument
      * @return
      */

-    public static YangInstanceIdentifier.PathArgument deSerialize(NormalizedNodeMessages.Node node,
-            NormalizedNodeMessages.PathArgument pathArgument){
+    public static YangInstanceIdentifier.PathArgument deSerialize(final NormalizedNodeMessages.Node node,
+            final NormalizedNodeMessages.PathArgument pathArgument){

         Preconditions.checkNotNull(node, "node should not be null");
         Preconditions.checkNotNull(pathArgument, "pathArgument should not be null");
         return new DeSerializer(null, node).deSerialize(pathArgument);
         Preconditions.checkNotNull(node, "node should not be null");
         Preconditions.checkNotNull(pathArgument, "pathArgument should not be null");
         return new DeSerializer(null, node).deSerialize(pathArgument);


@@ -137,7 +137,7 @@ public class NormalizedNodeSerializer {
 
         private NormalizedNodeMessages.InstanceIdentifier serializedPath;
 
 
         private NormalizedNodeMessages.InstanceIdentifier serializedPath;
 

-        private Serializer(NormalizedNode<?, ?> node) {
+        private Serializer(final NormalizedNode<?, ?> node) {

             this.node = node;
         }
 
             this.node = node;
         }
 


@@ -149,14 +149,14 @@ public class NormalizedNodeSerializer {
             return this.serialize(node).addAllCode(getCodes()).build();
         }
 
             return this.serialize(node).addAllCode(getCodes()).build();
         }
 

-        public NormalizedNodeMessages.Node serialize(YangInstanceIdentifier path) {
+        public NormalizedNodeMessages.Node serialize(final YangInstanceIdentifier path) {

             Builder builder = serialize(node);
             serializedPath = InstanceIdentifierUtils.toSerializable(path, this);
             return builder.addAllCode(getCodes()).build();
         }
 
         private NormalizedNodeMessages.Node.Builder serialize(
             Builder builder = serialize(node);
             serializedPath = InstanceIdentifierUtils.toSerializable(path, this);
             return builder.addAllCode(getCodes()).build();
         }
 
         private NormalizedNodeMessages.Node.Builder serialize(

-            NormalizedNode<?, ?> node) {
+            final NormalizedNode<?, ?> node) {

             NormalizedNodeMessages.Node.Builder builder =
                 NormalizedNodeMessages.Node.newBuilder();
 
             NormalizedNodeMessages.Node.Builder builder =
                 NormalizedNodeMessages.Node.newBuilder();
 


@@ -210,7 +210,7 @@ public class NormalizedNodeSerializer {
 
             m.put(CONTAINER_NODE_TYPE, new DeSerializationFunction() {
                 @Override
 
             m.put(CONTAINER_NODE_TYPE, new DeSerializationFunction() {
                 @Override

-                public NormalizedNode<?, ?> apply(DeSerializer deSerializer, NormalizedNodeMessages.Node node) {
+                public NormalizedNode<?, ?> apply(final DeSerializer deSerializer, final NormalizedNodeMessages.Node node) {

                     DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder = Builders.containerBuilder()
                             .withNodeIdentifier(deSerializer.toNodeIdentifier(node.getPathArgument()));
 
                     DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder = Builders.containerBuilder()
                             .withNodeIdentifier(deSerializer.toNodeIdentifier(node.getPathArgument()));
 


@@ -219,7 +219,7 @@ public class NormalizedNodeSerializer {
             });
             m.put(LEAF_NODE_TYPE, new DeSerializationFunction() {
                 @Override
             });
             m.put(LEAF_NODE_TYPE, new DeSerializationFunction() {
                 @Override

-                public NormalizedNode<?, ?> apply(DeSerializer deSerializer, NormalizedNodeMessages.Node node) {
+                public NormalizedNode<?, ?> apply(final DeSerializer deSerializer, final NormalizedNodeMessages.Node node) {

                     NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> builder = Builders.leafBuilder()
                             .withNodeIdentifier(deSerializer.toNodeIdentifier(node.getPathArgument()));
 
                     NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> builder = Builders.leafBuilder()
                             .withNodeIdentifier(deSerializer.toNodeIdentifier(node.getPathArgument()));
 


@@ -228,13 +228,13 @@ public class NormalizedNodeSerializer {
             });
             m.put(MAP_NODE_TYPE, new DeSerializationFunction() {
                 @Override
             });
             m.put(MAP_NODE_TYPE, new DeSerializationFunction() {
                 @Override

-                public NormalizedNode<?, ?> apply(DeSerializer deSerializer, NormalizedNodeMessages.Node node) {
+                public NormalizedNode<?, ?> apply(final DeSerializer deSerializer, final NormalizedNodeMessages.Node node) {

                     return deSerializer.buildCollectionNode(Builders.mapBuilder(), node);
                 }
             });
             m.put(MAP_ENTRY_NODE_TYPE, new DeSerializationFunction() {
                 @Override
                     return deSerializer.buildCollectionNode(Builders.mapBuilder(), node);
                 }
             });
             m.put(MAP_ENTRY_NODE_TYPE, new DeSerializationFunction() {
                 @Override

-                public NormalizedNode<?, ?> apply(DeSerializer deSerializer, NormalizedNodeMessages.Node node) {
+                public NormalizedNode<?, ?> apply(final DeSerializer deSerializer, final NormalizedNodeMessages.Node node) {

                     DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder =
                             Builders.mapEntryBuilder().withNodeIdentifier(deSerializer.toNodeIdentifierWithPredicates(
                                 node.getPathArgument()));
                     DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder =
                             Builders.mapEntryBuilder().withNodeIdentifier(deSerializer.toNodeIdentifierWithPredicates(
                                 node.getPathArgument()));


@@ -244,7 +244,7 @@ public class NormalizedNodeSerializer {
             });
             m.put(AUGMENTATION_NODE_TYPE, new DeSerializationFunction() {
                 @Override
             });
             m.put(AUGMENTATION_NODE_TYPE, new DeSerializationFunction() {
                 @Override

-                public NormalizedNode<?, ?> apply(DeSerializer deSerializer, NormalizedNodeMessages.Node node) {
+                public NormalizedNode<?, ?> apply(final DeSerializer deSerializer, final NormalizedNodeMessages.Node node) {

                     DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> builder =
                             Builders.augmentationBuilder().withNodeIdentifier(
                                 deSerializer.toAugmentationIdentifier(node.getPathArgument()));
                     DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> builder =
                             Builders.augmentationBuilder().withNodeIdentifier(
                                 deSerializer.toAugmentationIdentifier(node.getPathArgument()));


@@ -254,13 +254,13 @@ public class NormalizedNodeSerializer {
             });
             m.put(LEAF_SET_NODE_TYPE, new DeSerializationFunction() {
                 @Override
             });
             m.put(LEAF_SET_NODE_TYPE, new DeSerializationFunction() {
                 @Override

-                public NormalizedNode<?, ?> apply(DeSerializer deSerializer, NormalizedNodeMessages.Node node) {
+                public NormalizedNode<?, ?> apply(final DeSerializer deSerializer, final NormalizedNodeMessages.Node node) {

                     return deSerializer.buildListNode(Builders.leafSetBuilder(), node);
                 }
             });
             m.put(LEAF_SET_ENTRY_NODE_TYPE, new DeSerializationFunction() {
                 @Override
                     return deSerializer.buildListNode(Builders.leafSetBuilder(), node);
                 }
             });
             m.put(LEAF_SET_ENTRY_NODE_TYPE, new DeSerializationFunction() {
                 @Override

-                public NormalizedNode<?, ?> apply(DeSerializer deSerializer, NormalizedNodeMessages.Node node) {
+                public NormalizedNode<?, ?> apply(final DeSerializer deSerializer, final NormalizedNodeMessages.Node node) {

                     NormalizedNodeAttrBuilder<NodeWithValue, Object, LeafSetEntryNode<Object>> builder =
                             Builders.leafSetEntryBuilder().withNodeIdentifier(deSerializer.toNodeWithValue(
                                 node.getPathArgument()));
                     NormalizedNodeAttrBuilder<NodeWithValue, Object, LeafSetEntryNode<Object>> builder =
                             Builders.leafSetEntryBuilder().withNodeIdentifier(deSerializer.toNodeWithValue(
                                 node.getPathArgument()));


@@ -270,7 +270,7 @@ public class NormalizedNodeSerializer {
             });
             m.put(CHOICE_NODE_TYPE, new DeSerializationFunction() {
                 @Override
             });
             m.put(CHOICE_NODE_TYPE, new DeSerializationFunction() {
                 @Override

-                public NormalizedNode<?, ?> apply(DeSerializer deSerializer, NormalizedNodeMessages.Node node) {
+                public NormalizedNode<?, ?> apply(final DeSerializer deSerializer, final NormalizedNodeMessages.Node node) {

                     DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> builder = Builders.choiceBuilder()
                             .withNodeIdentifier(deSerializer.toNodeIdentifier(node.getPathArgument()));
 
                     DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> builder = Builders.choiceBuilder()
                             .withNodeIdentifier(deSerializer.toNodeIdentifier(node.getPathArgument()));
 


@@ -279,25 +279,25 @@ public class NormalizedNodeSerializer {
             });
             m.put(ORDERED_LEAF_SET_NODE_TYPE, new DeSerializationFunction() {
                 @Override
             });
             m.put(ORDERED_LEAF_SET_NODE_TYPE, new DeSerializationFunction() {
                 @Override

-                public NormalizedNode<?, ?> apply(DeSerializer deSerializer, NormalizedNodeMessages.Node node) {
+                public NormalizedNode<?, ?> apply(final DeSerializer deSerializer, final NormalizedNodeMessages.Node node) {

                     return deSerializer.buildListNode(Builders.orderedLeafSetBuilder(), node);
                 }
             });
             m.put(ORDERED_MAP_NODE_TYPE, new DeSerializationFunction() {
                 @Override
                     return deSerializer.buildListNode(Builders.orderedLeafSetBuilder(), node);
                 }
             });
             m.put(ORDERED_MAP_NODE_TYPE, new DeSerializationFunction() {
                 @Override

-                public NormalizedNode<?, ?> apply(DeSerializer deSerializer, NormalizedNodeMessages.Node node) {
+                public NormalizedNode<?, ?> apply(final DeSerializer deSerializer, final NormalizedNodeMessages.Node node) {

                     return deSerializer.buildCollectionNode(Builders.orderedMapBuilder(), node);
                 }
             });
             m.put(UNKEYED_LIST_NODE_TYPE, new DeSerializationFunction() {
                 @Override
                     return deSerializer.buildCollectionNode(Builders.orderedMapBuilder(), node);
                 }
             });
             m.put(UNKEYED_LIST_NODE_TYPE, new DeSerializationFunction() {
                 @Override

-                public NormalizedNode<?, ?> apply(DeSerializer deSerializer, NormalizedNodeMessages.Node node) {
+                public NormalizedNode<?, ?> apply(final DeSerializer deSerializer, final NormalizedNodeMessages.Node node) {

                     return deSerializer.buildCollectionNode(Builders.unkeyedListBuilder(), node);
                 }
             });
             m.put(UNKEYED_LIST_ENTRY_NODE_TYPE, new DeSerializationFunction() {
                 @Override
                     return deSerializer.buildCollectionNode(Builders.unkeyedListBuilder(), node);
                 }
             });
             m.put(UNKEYED_LIST_ENTRY_NODE_TYPE, new DeSerializationFunction() {
                 @Override

-                public NormalizedNode<?, ?> apply(DeSerializer deSerializer, NormalizedNodeMessages.Node node) {
+                public NormalizedNode<?, ?> apply(final DeSerializer deSerializer, final NormalizedNodeMessages.Node node) {

                     DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> builder =
                             Builders.unkeyedListEntryBuilder().withNodeIdentifier(deSerializer.toNodeIdentifier(
                                 node.getPathArgument()));
                     DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> builder =
                             Builders.unkeyedListEntryBuilder().withNodeIdentifier(deSerializer.toNodeIdentifier(
                                 node.getPathArgument()));


@@ -307,7 +307,7 @@ public class NormalizedNodeSerializer {
             });
             m.put(ANY_XML_NODE_TYPE, new DeSerializationFunction() {
                 @Override
             });
             m.put(ANY_XML_NODE_TYPE, new DeSerializationFunction() {
                 @Override

-                public NormalizedNode<?, ?> apply(DeSerializer deSerializer, NormalizedNodeMessages.Node node) {
+                public NormalizedNode<?, ?> apply(final DeSerializer deSerializer, final NormalizedNodeMessages.Node node) {

                     NormalizedNodeAttrBuilder<NodeIdentifier, DOMSource, AnyXmlNode> builder = Builders.anyXmlBuilder()
                             .withNodeIdentifier(deSerializer.toNodeIdentifier(node.getPathArgument()));
 
                     NormalizedNodeAttrBuilder<NodeIdentifier, DOMSource, AnyXmlNode> builder = Builders.anyXmlBuilder()
                             .withNodeIdentifier(deSerializer.toNodeIdentifier(node.getPathArgument()));
 


@@ -322,8 +322,8 @@ public class NormalizedNodeSerializer {
         private final NormalizedNodeMessages.InstanceIdentifier path;
         private YangInstanceIdentifier deserializedPath;
 
         private final NormalizedNodeMessages.InstanceIdentifier path;
         private YangInstanceIdentifier deserializedPath;
 

-        public DeSerializer(NormalizedNodeMessages.InstanceIdentifier path,
-                NormalizedNodeMessages.Node node) {
+        public DeSerializer(final NormalizedNodeMessages.InstanceIdentifier path,
+                final NormalizedNodeMessages.Node node) {

             super(node.getCodeList());
             this.path = path;
             this.node = node;
             super(node.getCodeList());
             this.path = path;
             this.node = node;


@@ -342,7 +342,7 @@ public class NormalizedNodeSerializer {
             return deserializedNode;
         }
 
             return deserializedNode;
         }
 

-        private NormalizedNode<?, ?> deSerialize(NormalizedNodeMessages.Node node){
+        private NormalizedNode<?, ?> deSerialize(final NormalizedNodeMessages.Node node){

             Preconditions.checkNotNull(node, "node should not be null");
 
             DeSerializationFunction deSerializationFunction = DESERIALIZATION_FUNCTIONS.get(
             Preconditions.checkNotNull(node, "node should not be null");
 
             DeSerializationFunction deSerializationFunction = DESERIALIZATION_FUNCTIONS.get(


@@ -353,8 +353,8 @@ public class NormalizedNodeSerializer {
 
 
         private NormalizedNode<?, ?> buildCollectionNode(
 
 
         private NormalizedNode<?, ?> buildCollectionNode(

-            CollectionNodeBuilder builder,
-            NormalizedNodeMessages.Node node) {
+            final CollectionNodeBuilder builder,
+            final NormalizedNodeMessages.Node node) {

 
             builder.withNodeIdentifier(toNodeIdentifier(node.getPathArgument()));
 
 
             builder.withNodeIdentifier(toNodeIdentifier(node.getPathArgument()));
 


@@ -367,8 +367,8 @@ public class NormalizedNodeSerializer {
 
 
         private NormalizedNode<?, ?> buildListNode(
 
 
         private NormalizedNode<?, ?> buildListNode(

-            ListNodeBuilder<Object, LeafSetEntryNode<Object>> builder,
-            NormalizedNodeMessages.Node node) {
+            final ListNodeBuilder<Object, LeafSetEntryNode<Object>> builder,
+            final NormalizedNodeMessages.Node node) {

             builder.withNodeIdentifier(toNodeIdentifier(node.getPathArgument()));
 
             for(NormalizedNodeMessages.Node child : node.getChildList()){
             builder.withNodeIdentifier(toNodeIdentifier(node.getPathArgument()));
 
             for(NormalizedNodeMessages.Node child : node.getChildList()){


@@ -378,7 +378,7 @@ public class NormalizedNodeSerializer {
             return builder.build();
         }
 
             return builder.build();
         }
 

-        private NormalizedNode<?, ?> buildDataContainer(DataContainerNodeBuilder<?, ?> builder, NormalizedNodeMessages.Node node){
+        private NormalizedNode<?, ?> buildDataContainer(final DataContainerNodeBuilder<?, ?> builder, final NormalizedNodeMessages.Node node){

 
             for(NormalizedNodeMessages.Node child : node.getChildList()){
                 builder.withChild((DataContainerChild<?, ?>) deSerialize(child));
 
             for(NormalizedNodeMessages.Node child : node.getChildList()){
                 builder.withChild((DataContainerChild<?, ?>) deSerialize(child));


@@ -389,7 +389,7 @@ public class NormalizedNodeSerializer {
             return builder.build();
         }
 
             return builder.build();
         }
 

-        private NormalizedNode<?, ?> buildNormalizedNode(NormalizedNodeAttrBuilder builder, NormalizedNodeMessages.Node node){
+        private NormalizedNode<?, ?> buildNormalizedNode(final NormalizedNodeAttrBuilder builder, final NormalizedNodeMessages.Node node){

 
             builder.withValue(ValueSerializer.deSerialize(this, node));
 
 
             builder.withValue(ValueSerializer.deSerialize(this, node));
 


@@ -399,29 +399,25 @@ public class NormalizedNodeSerializer {
 
         }
 
 
         }
 

-
-        private YangInstanceIdentifier.NodeIdentifierWithPredicates toNodeIdentifierWithPredicates(
-            NormalizedNodeMessages.PathArgument path) {
-            return (YangInstanceIdentifier.NodeIdentifierWithPredicates) PathArgumentSerializer.deSerialize(this, path);
+        private NodeIdentifierWithPredicates toNodeIdentifierWithPredicates(
+            final NormalizedNodeMessages.PathArgument path) {
+            return (NodeIdentifierWithPredicates) PathArgumentSerializer.deSerialize(this, path);

         }
 
         }
 

-        private YangInstanceIdentifier.AugmentationIdentifier toAugmentationIdentifier(
-            NormalizedNodeMessages.PathArgument path) {
-            return (YangInstanceIdentifier.AugmentationIdentifier) PathArgumentSerializer.deSerialize(this, path);
+        private AugmentationIdentifier toAugmentationIdentifier(final NormalizedNodeMessages.PathArgument path) {
+            return (AugmentationIdentifier) PathArgumentSerializer.deSerialize(this, path);

         }
 
         }
 

-        private YangInstanceIdentifier.NodeWithValue toNodeWithValue(
-            NormalizedNodeMessages.PathArgument path) {
-            return (YangInstanceIdentifier.NodeWithValue) PathArgumentSerializer.deSerialize(
-                this, path);
+        @SuppressWarnings("unchecked")
+        private <T> NodeWithValue<T> toNodeWithValue(final NormalizedNodeMessages.PathArgument path) {
+            return (NodeWithValue<T>) PathArgumentSerializer.deSerialize(this, path);

         }
 
         }
 

-        private NodeIdentifier toNodeIdentifier(NormalizedNodeMessages.PathArgument path){
+        private NodeIdentifier toNodeIdentifier(final NormalizedNodeMessages.PathArgument path){

             return (NodeIdentifier) PathArgumentSerializer.deSerialize(this, path);
         }
 
             return (NodeIdentifier) PathArgumentSerializer.deSerialize(this, path);
         }
 

-        public YangInstanceIdentifier.PathArgument deSerialize(
-            NormalizedNodeMessages.PathArgument pathArgument) {
+        public YangInstanceIdentifier.PathArgument deSerialize(final NormalizedNodeMessages.PathArgument pathArgument) {

             return PathArgumentSerializer.deSerialize(this, pathArgument);
         }
 
             return PathArgumentSerializer.deSerialize(this, pathArgument);
         }
 

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/PathArgumentSerializer.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/PathArgumentSerializer.java
index bf10316fd5d8b795154a1caf6d827e1e911d1d5c..989bd266e6dadd8cc56ed3a07e7c66abbd69c64e 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/PathArgumentSerializer.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/PathArgumentSerializer.java
@@ -73,8 +73,8 @@ public class PathArgumentSerializer {
             public Iterable<? extends NormalizedNodeMessages.PathArgumentAttribute> get(
                     QNameSerializationContext context, YangInstanceIdentifier.PathArgument pathArgument) {
 
             public Iterable<? extends NormalizedNodeMessages.PathArgumentAttribute> get(
                     QNameSerializationContext context, YangInstanceIdentifier.PathArgument pathArgument) {
 

-                YangInstanceIdentifier.NodeWithValue identifier
-                    = (YangInstanceIdentifier.NodeWithValue) pathArgument;
+                YangInstanceIdentifier.NodeWithValue<?> identifier
+                    = (YangInstanceIdentifier.NodeWithValue<?>) pathArgument;

 
                 NormalizedNodeMessages.PathArgumentAttribute attribute =
                     buildAttribute(context, null, identifier.getValue());
 
                 NormalizedNodeMessages.PathArgumentAttribute attribute =
                     buildAttribute(context, null, identifier.getValue());


@@ -211,8 +211,8 @@ public class PathArgumentSerializer {
         switch(PathArgumentType.values()[pathArgument.getIntType()]){
             case NODE_IDENTIFIER_WITH_VALUE : {
 
         switch(PathArgumentType.values()[pathArgument.getIntType()]){
             case NODE_IDENTIFIER_WITH_VALUE : {
 

-                YangInstanceIdentifier.NodeWithValue nodeWithValue =
-                    new YangInstanceIdentifier.NodeWithValue(
+                YangInstanceIdentifier.NodeWithValue<?> nodeWithValue =
+                    new YangInstanceIdentifier.NodeWithValue<>(

                         QNameFactory.create(qNameToString(context, pathArgument.getNodeType())),
                         parseAttribute(context, pathArgument.getAttribute(0)));
 
                         QNameFactory.create(qNameToString(context, pathArgument.getNodeType())),
                         parseAttribute(context, pathArgument.getAttribute(0)));
 

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/AbstractNormalizedNodeDataOutput.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/AbstractNormalizedNodeDataOutput.java
index abe1f8c588fb53fc9108c00afb1de9134805d66c..5512f3171601d96f1710e8048f3c19993369d0bc 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/AbstractNormalizedNodeDataOutput.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/AbstractNormalizedNodeDataOutput.java
@@ -17,6 +17,11 @@ import java.util.Map;
 import java.util.Set;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import java.util.Set;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;

+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;

 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;


@@ -147,7 +152,7 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
     }
 
     @Override
     }
 
     @Override

-    public void leafNode(final YangInstanceIdentifier.NodeIdentifier name, final Object value) throws IOException, IllegalArgumentException {
+    public void leafNode(final NodeIdentifier name, final Object value) throws IOException, IllegalArgumentException {

         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Writing a new leaf node");
         startNode(name.getNodeType(), NodeTypes.LEAF_NODE);
         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Writing a new leaf node");
         startNode(name.getNodeType(), NodeTypes.LEAF_NODE);


@@ -156,7 +161,7 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
     }
 
     @Override
     }
 
     @Override

-    public void startLeafSet(final YangInstanceIdentifier.NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {
+    public void startLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {

         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Starting a new leaf set");
 
         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Starting a new leaf set");
 


@@ -165,7 +170,7 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
     }
 
     @Override
     }
 
     @Override

-    public void startOrderedLeafSet(final YangInstanceIdentifier.NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {
+    public void startOrderedLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {

         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Starting a new ordered leaf set");
 
         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Starting a new ordered leaf set");
 


@@ -189,7 +194,7 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
     }
 
     @Override
     }
 
     @Override

-    public void startContainerNode(final YangInstanceIdentifier.NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {
+    public void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {

         Preconditions.checkNotNull(name, "Node identifier should not be null");
 
         LOG.debug("Starting a new container node");
         Preconditions.checkNotNull(name, "Node identifier should not be null");
 
         LOG.debug("Starting a new container node");


@@ -198,7 +203,7 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
     }
 
     @Override
     }
 
     @Override

-    public void startYangModeledAnyXmlNode(final YangInstanceIdentifier.NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {
+    public void startYangModeledAnyXmlNode(final NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {

         Preconditions.checkNotNull(name, "Node identifier should not be null");
 
         LOG.debug("Starting a new yang modeled anyXml node");
         Preconditions.checkNotNull(name, "Node identifier should not be null");
 
         LOG.debug("Starting a new yang modeled anyXml node");


@@ -207,7 +212,7 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
     }
 
     @Override
     }
 
     @Override

-    public void startUnkeyedList(final YangInstanceIdentifier.NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {
+    public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {

         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Starting a new unkeyed list");
 
         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Starting a new unkeyed list");
 


@@ -215,7 +220,7 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
     }
 
     @Override
     }
 
     @Override

-    public void startUnkeyedListItem(final YangInstanceIdentifier.NodeIdentifier name, final int childSizeHint) throws IOException, IllegalStateException {
+    public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException, IllegalStateException {

         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Starting a new unkeyed list item");
 
         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Starting a new unkeyed list item");
 


@@ -223,7 +228,7 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
     }
 
     @Override
     }
 
     @Override

-    public void startMapNode(final YangInstanceIdentifier.NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {
+    public void startMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {

         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Starting a new map node");
 
         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Starting a new map node");
 


@@ -231,7 +236,7 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
     }
 
     @Override
     }
 
     @Override

-    public void startMapEntryNode(final YangInstanceIdentifier.NodeIdentifierWithPredicates identifier, final int childSizeHint) throws IOException, IllegalArgumentException {
+    public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint) throws IOException, IllegalArgumentException {

         Preconditions.checkNotNull(identifier, "Node identifier should not be null");
         LOG.debug("Starting a new map entry node");
         startNode(identifier.getNodeType(), NodeTypes.MAP_ENTRY_NODE);
         Preconditions.checkNotNull(identifier, "Node identifier should not be null");
         LOG.debug("Starting a new map entry node");
         startNode(identifier.getNodeType(), NodeTypes.MAP_ENTRY_NODE);


@@ -241,7 +246,7 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
     }
 
     @Override
     }
 
     @Override

-    public void startOrderedMapNode(final YangInstanceIdentifier.NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {
+    public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {

         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Starting a new ordered map node");
 
         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Starting a new ordered map node");
 


@@ -249,7 +254,7 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
     }
 
     @Override
     }
 
     @Override

-    public void startChoiceNode(final YangInstanceIdentifier.NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {
+    public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) throws IOException, IllegalArgumentException {

         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Starting a new choice node");
 
         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Starting a new choice node");
 


@@ -257,7 +262,7 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
     }
 
     @Override
     }
 
     @Override

-    public void startAugmentationNode(final YangInstanceIdentifier.AugmentationIdentifier identifier) throws IOException, IllegalArgumentException {
+    public void startAugmentationNode(final AugmentationIdentifier identifier) throws IOException, IllegalArgumentException {

         Preconditions.checkNotNull(identifier, "Node identifier should not be null");
         LOG.debug("Starting a new augmentation node");
 
         Preconditions.checkNotNull(identifier, "Node identifier should not be null");
         LOG.debug("Starting a new augmentation node");
 


@@ -266,7 +271,7 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
     }
 
     @Override
     }
 
     @Override

-    public void anyxmlNode(final YangInstanceIdentifier.NodeIdentifier name, final Object value) throws IOException, IllegalArgumentException {
+    public void anyxmlNode(final NodeIdentifier name, final Object value) throws IOException, IllegalArgumentException {

         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Writing a new xml node");
 
         Preconditions.checkNotNull(name, "Node identifier should not be null");
         LOG.debug("Writing a new xml node");
 


@@ -323,16 +328,16 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
     }
 
     private void writeYangInstanceIdentifierInternal(final YangInstanceIdentifier identifier) throws IOException {
     }
 
     private void writeYangInstanceIdentifierInternal(final YangInstanceIdentifier identifier) throws IOException {

-        Collection<YangInstanceIdentifier.PathArgument> pathArguments = identifier.getPathArguments();
+        Collection<PathArgument> pathArguments = identifier.getPathArguments();

         output.writeInt(pathArguments.size());
 
         output.writeInt(pathArguments.size());
 

-        for(YangInstanceIdentifier.PathArgument pathArgument : pathArguments) {
+        for(PathArgument pathArgument : pathArguments) {

             writePathArgument(pathArgument);
         }
     }
 
     @Override
             writePathArgument(pathArgument);
         }
     }
 
     @Override

-    public void writePathArgument(final YangInstanceIdentifier.PathArgument pathArgument) throws IOException {
+    public void writePathArgument(final PathArgument pathArgument) throws IOException {

 
         byte type = PathArgumentTypes.getSerializablePathArgumentType(pathArgument);
 
 
         byte type = PathArgumentTypes.getSerializablePathArgumentType(pathArgument);
 


@@ -341,16 +346,15 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
         switch(type) {
             case PathArgumentTypes.NODE_IDENTIFIER:
 
         switch(type) {
             case PathArgumentTypes.NODE_IDENTIFIER:
 

-                YangInstanceIdentifier.NodeIdentifier nodeIdentifier =
-                    (YangInstanceIdentifier.NodeIdentifier) pathArgument;
+                NodeIdentifier nodeIdentifier = (NodeIdentifier) pathArgument;

 
                 writeQName(nodeIdentifier.getNodeType());
                 break;
 
             case PathArgumentTypes.NODE_IDENTIFIER_WITH_PREDICATES:
 
 
                 writeQName(nodeIdentifier.getNodeType());
                 break;
 
             case PathArgumentTypes.NODE_IDENTIFIER_WITH_PREDICATES:
 

-                YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifierWithPredicates =
-                    (YangInstanceIdentifier.NodeIdentifierWithPredicates) pathArgument;
+                NodeIdentifierWithPredicates nodeIdentifierWithPredicates =
+                    (NodeIdentifierWithPredicates) pathArgument;

                 writeQName(nodeIdentifierWithPredicates.getNodeType());
 
                 writeKeyValueMap(nodeIdentifierWithPredicates.getKeyValues());
                 writeQName(nodeIdentifierWithPredicates.getNodeType());
 
                 writeKeyValueMap(nodeIdentifierWithPredicates.getKeyValues());


@@ -358,8 +362,7 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
 
             case PathArgumentTypes.NODE_IDENTIFIER_WITH_VALUE :
 
 
             case PathArgumentTypes.NODE_IDENTIFIER_WITH_VALUE :
 

-                YangInstanceIdentifier.NodeWithValue nodeWithValue =
-                    (YangInstanceIdentifier.NodeWithValue) pathArgument;
+                NodeWithValue<?> nodeWithValue = (NodeWithValue<?>) pathArgument;

 
                 writeQName(nodeWithValue.getNodeType());
                 writeObject(nodeWithValue.getValue());
 
                 writeQName(nodeWithValue.getNodeType());
                 writeObject(nodeWithValue.getValue());


@@ -367,8 +370,7 @@ abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOut
 
             case PathArgumentTypes.AUGMENTATION_IDENTIFIER :
 
 
             case PathArgumentTypes.AUGMENTATION_IDENTIFIER :
 

-                YangInstanceIdentifier.AugmentationIdentifier augmentationIdentifier =
-                    (YangInstanceIdentifier.AugmentationIdentifier) pathArgument;
+                AugmentationIdentifier augmentationIdentifier = (AugmentationIdentifier) pathArgument;

 
                 // No Qname in augmentation identifier
                 writeQNameSet(augmentationIdentifier.getPossibleChildNames());
 
                 // No Qname in augmentation identifier
                 writeQNameSet(augmentationIdentifier.getPossibleChildNames());

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeInputStreamReader.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeInputStreamReader.java
index 7ed50ff731bb5bdafc620e53e388cf2b1cd3d4c8..a31a611d337b60a6658efe05fd559e3f762dded5 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeInputStreamReader.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeInputStreamReader.java
@@ -63,8 +63,7 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput,
     private NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier,
                                       Object, LeafNode<Object>> leafBuilder;
 
     private NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier,
                                       Object, LeafNode<Object>> leafBuilder;
 

-    private NormalizedNodeAttrBuilder<NodeWithValue, Object,
-                                      LeafSetEntryNode<Object>> leafSetEntryBuilder;
+    private NormalizedNodeAttrBuilder<NodeWithValue, Object, LeafSetEntryNode<Object>> leafSetEntryBuilder;

 
     private final StringBuilder reusableStringBuilder = new StringBuilder(50);
 
 
     private final StringBuilder reusableStringBuilder = new StringBuilder(50);
 


@@ -140,7 +139,7 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput,
                 }
 
                 Object value = readObject();
                 }
 
                 Object value = readObject();

-                NodeWithValue<?> leafIdentifier = new NodeWithValue<>(name, value);
+                NodeWithValue<Object> leafIdentifier = new NodeWithValue<>(name, value);

 
                 LOG.debug("Reading leaf set entry node {}, value {}", leafIdentifier, value);
 
 
                 LOG.debug("Reading leaf set entry node {}, value {}", leafIdentifier, value);
 


@@ -390,7 +389,7 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput,
                 return new NodeIdentifierWithPredicates(readQName(), readKeyValueMap());
 
             case PathArgumentTypes.NODE_IDENTIFIER_WITH_VALUE :
                 return new NodeIdentifierWithPredicates(readQName(), readKeyValueMap());
 
             case PathArgumentTypes.NODE_IDENTIFIER_WITH_VALUE :

-                return new NodeWithValue(readQName(), readObject());
+                return new NodeWithValue<>(readQName(), readObject());

 
             default :
                 return null;
 
             default :
                 return null;

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/util/InstanceIdentifierUtils.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/util/InstanceIdentifierUtils.java
index aeb31779bf4b973f1e00e7c13758bcf09df5e24f..b72ca5800a43b7af12e1f5dfc5d0f81682e21a00 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/util/InstanceIdentifierUtils.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/util/InstanceIdentifierUtils.java
@@ -19,6 +19,10 @@ import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessa
 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;

+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import java.util.ArrayList;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import java.util.ArrayList;


@@ -67,12 +71,11 @@ public class InstanceIdentifierUtils {
             NormalizedNodeMessages.InstanceIdentifier.newBuilder();
 
         try {
             NormalizedNodeMessages.InstanceIdentifier.newBuilder();
 
         try {

-            for (org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.
-                                            PathArgument pathArgument : path.getPathArguments()) {
+            for (PathArgument pathArgument : path.getPathArguments()) {

                 NormalizedNodeMessages.PathArgument serializablePathArgument;
                 if(context == null) {
                     String nodeType = "";
                 NormalizedNodeMessages.PathArgument serializablePathArgument;
                 if(context == null) {
                     String nodeType = "";

-                    if(!(pathArgument instanceof YangInstanceIdentifier.AugmentationIdentifier)){
+                    if (!(pathArgument instanceof AugmentationIdentifier)) {

                         nodeType = pathArgument.getNodeType().toString();
                     }
 
                         nodeType = pathArgument.getNodeType().toString();
                     }
 


@@ -109,7 +112,7 @@ public class InstanceIdentifierUtils {
     public static YangInstanceIdentifier fromSerializable(NormalizedNodeMessages.InstanceIdentifier path,
             QNameDeSerializationContext context) {
 
     public static YangInstanceIdentifier fromSerializable(NormalizedNodeMessages.InstanceIdentifier path,
             QNameDeSerializationContext context) {
 

-        List<YangInstanceIdentifier.PathArgument> pathArguments = new ArrayList<>();
+        List<PathArgument> pathArguments = new ArrayList<>();

 
         for(NormalizedNodeMessages.PathArgument pathArgument : path.getArgumentsList()) {
             if(context == null || pathArgument.hasType()) {
 
         for(NormalizedNodeMessages.PathArgument pathArgument : path.getArgumentsList()) {
             if(context == null || pathArgument.hasType()) {


@@ -155,14 +158,11 @@ public class InstanceIdentifierUtils {
      * @return
      */
     private static Iterable<? extends NormalizedNodeMessages.Attribute> getPathArgumentAttributes(
      * @return
      */
     private static Iterable<? extends NormalizedNodeMessages.Attribute> getPathArgumentAttributes(

-        YangInstanceIdentifier.PathArgument pathArgument) {
+        PathArgument pathArgument) {

         List<NormalizedNodeMessages.Attribute> attributes = new ArrayList<>();
 
         List<NormalizedNodeMessages.Attribute> attributes = new ArrayList<>();
 

-
-
-        if (pathArgument instanceof YangInstanceIdentifier.NodeWithValue) {
-            YangInstanceIdentifier.NodeWithValue identifier
-                = (YangInstanceIdentifier.NodeWithValue) pathArgument;
+        if (pathArgument instanceof NodeWithValue) {
+            NodeWithValue<?> identifier = (NodeWithValue<?>) pathArgument;

 
             NormalizedNodeMessages.Attribute attribute =
                 NormalizedNodeMessages.Attribute.newBuilder()
 
             NormalizedNodeMessages.Attribute attribute =
                 NormalizedNodeMessages.Attribute.newBuilder()


@@ -172,9 +172,8 @@ public class InstanceIdentifierUtils {
                     .build();
 
             attributes.add(attribute);
                     .build();
 
             attributes.add(attribute);

-        } else if (pathArgument instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates) {
-            YangInstanceIdentifier.NodeIdentifierWithPredicates identifier
-                = (YangInstanceIdentifier.NodeIdentifierWithPredicates) pathArgument;
+        } else if (pathArgument instanceof NodeIdentifierWithPredicates) {
+            NodeIdentifierWithPredicates identifier = (NodeIdentifierWithPredicates) pathArgument;

 
             for (QName key : identifier.getKeyValues().keySet()) {
                 Object value = identifier.getKeyValues().get(key);
 
             for (QName key : identifier.getKeyValues().keySet()) {
                 Object value = identifier.getKeyValues().get(key);


@@ -189,9 +188,8 @@ public class InstanceIdentifierUtils {
 
             }
 
 
             }
 

-        } else if(pathArgument instanceof YangInstanceIdentifier.AugmentationIdentifier) {
-            YangInstanceIdentifier.AugmentationIdentifier identifier
-                = (YangInstanceIdentifier.AugmentationIdentifier) pathArgument;
+        } else if(pathArgument instanceof AugmentationIdentifier) {
+            AugmentationIdentifier identifier = (AugmentationIdentifier) pathArgument;

 
             for (QName key : identifier.getPossibleChildNames()) {
                 Object value = key;
 
             for (QName key : identifier.getPossibleChildNames()) {
                 Object value = key;


@@ -217,27 +215,25 @@ public class InstanceIdentifierUtils {
      * @param pathArgument protocol buffer PathArgument
      * @return MD-SAL PathArgument
      */
      * @param pathArgument protocol buffer PathArgument
      * @return MD-SAL PathArgument
      */

-    private static YangInstanceIdentifier.PathArgument parsePathArgument(
+    private static PathArgument parsePathArgument(

             NormalizedNodeMessages.PathArgument pathArgument) {
             NormalizedNodeMessages.PathArgument pathArgument) {

-        if (YangInstanceIdentifier.NodeWithValue.class.getSimpleName().equals(pathArgument.getType())) {
+        if (NodeWithValue.class.getSimpleName().equals(pathArgument.getType())) {

 
 

-            YangInstanceIdentifier.NodeWithValue nodeWithValue =
-                new YangInstanceIdentifier.NodeWithValue(
+            NodeWithValue<?> nodeWithValue = new NodeWithValue<>(

                     QNameFactory.create(pathArgument.getNodeType().getValue()),
                     parseAttribute(pathArgument.getAttributes(0)));
 
             return nodeWithValue;
 
                     QNameFactory.create(pathArgument.getNodeType().getValue()),
                     parseAttribute(pathArgument.getAttributes(0)));
 
             return nodeWithValue;
 

-        } else if(YangInstanceIdentifier.NodeIdentifierWithPredicates.class.getSimpleName().equals(pathArgument.getType())){
+        } else if(NodeIdentifierWithPredicates.class.getSimpleName().equals(pathArgument.getType())){

 
 

-            YangInstanceIdentifier.NodeIdentifierWithPredicates
-                nodeIdentifierWithPredicates =
-                new YangInstanceIdentifier.NodeIdentifierWithPredicates(
+            NodeIdentifierWithPredicates nodeIdentifierWithPredicates =
+                new NodeIdentifierWithPredicates(

                     QNameFactory.create(pathArgument.getNodeType().getValue()), toAttributesMap(pathArgument.getAttributesList()));
 
             return nodeIdentifierWithPredicates;
 
                     QNameFactory.create(pathArgument.getNodeType().getValue()), toAttributesMap(pathArgument.getAttributesList()));
 
             return nodeIdentifierWithPredicates;
 

-        } else if(YangInstanceIdentifier.AugmentationIdentifier.class.getSimpleName().equals(pathArgument.getType())){
+        } else if(AugmentationIdentifier.class.getSimpleName().equals(pathArgument.getType())){

 
             Set<QName> qNameSet = new HashSet<>();
 
 
             Set<QName> qNameSet = new HashSet<>();
 


@@ -245,7 +241,7 @@ public class InstanceIdentifierUtils {
                 qNameSet.add(QNameFactory.create(attribute.getValue()));
             }
 
                 qNameSet.add(QNameFactory.create(attribute.getValue()));
             }
 

-            return new YangInstanceIdentifier.AugmentationIdentifier(qNameSet);
+            return new AugmentationIdentifier(qNameSet);

         }
 
         return NodeIdentifierFactory.getArgument(pathArgument.getValue());
         }
 
         return NodeIdentifierFactory.getArgument(pathArgument.getValue());

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/schema/provider/impl/RemoteYangTextSourceProviderImpl.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/schema/provider/impl/RemoteYangTextSourceProviderImpl.java
index 07d1714680e688e622fc838f82554dcc3737bde3..0b07eeb19bb049305d2fff05f481daba4ee25bc8 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/schema/provider/impl/RemoteYangTextSourceProviderImpl.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/schema/provider/impl/RemoteYangTextSourceProviderImpl.java
@@ -48,7 +48,7 @@ public class RemoteYangTextSourceProviderImpl implements RemoteYangTextSourcePro
         LOG.trace("Sending yang schema source for {}", identifier);
 
         final Promise<YangTextSchemaSourceSerializationProxy> promise = akka.dispatch.Futures.promise();
         LOG.trace("Sending yang schema source for {}", identifier);
 
         final Promise<YangTextSchemaSourceSerializationProxy> promise = akka.dispatch.Futures.promise();

-        CheckedFuture future = repository.getSchemaSource(identifier, YangTextSchemaSource.class);
+        CheckedFuture<YangTextSchemaSource, ?> future = repository.getSchemaSource(identifier, YangTextSchemaSource.class);

 
         Futures.addCallback(future, new FutureCallback<YangTextSchemaSource>() {
             @Override
 
         Futures.addCallback(future, new FutureCallback<YangTextSchemaSource>() {
             @Override

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/xml/codec/XmlUtils.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/xml/codec/XmlUtils.java
index 85d2c31ad3bff437ffcd77d922ab0269c652857a..7b12a6851e9868232be6151a390298379845de42 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/xml/codec/XmlUtils.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/xml/codec/XmlUtils.java
@@ -24,63 +24,63 @@ import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  */
 public class XmlUtils {
 
  */
 public class XmlUtils {
 

-  public static final XmlCodecProvider DEFAULT_XML_CODEC_PROVIDER = new XmlCodecProvider() {
-    @Override
-    public TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> codecFor(final TypeDefinition<?> baseType) {
-      return TypeDefinitionAwareCodec.from(baseType);
-    }
-  };
+    public static final XmlCodecProvider DEFAULT_XML_CODEC_PROVIDER = new XmlCodecProvider() {
+        @Override
+        public TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> codecFor(final TypeDefinition<?> baseType) {
+            return TypeDefinitionAwareCodec.from(baseType);
+        }
+    };

 
 

-  private XmlUtils() {
-  }
+    private XmlUtils() {
+    }

 
 

-  public static TypeDefinition<?> resolveBaseTypeFrom(final @Nonnull TypeDefinition<?> type) {
-    TypeDefinition<?> superType = type;
-    while (superType.getBaseType() != null) {
-      superType = superType.getBaseType();
+    public static TypeDefinition<?> resolveBaseTypeFrom(final @Nonnull TypeDefinition<?> type) {
+        TypeDefinition<?> superType = type;
+        while (superType.getBaseType() != null) {
+            superType = superType.getBaseType();
+        }
+        return superType;

     }
     }

-    return superType;
-  }

 
 

-  /**
-   * This code is picked from yangtools and modified to add type of instance identifier
-   * output of instance identifier something like below for a flow ref composite node of type instance identifier,
-   * which has path arguments with predicates, whose value is of type java.lang.short
-   * <flow-ref xmlns:bgkj="urn:opendaylight:flow:inventory" xmlns:jdlk="urn:opendaylight:inventory">
-   *   /jdlk:nodes/jdlk:node[jdlk:id='openflow:205558455098190@java.lang.String']
-   *   /bgkj:table[bgkj:id='3@java.lang.Short']
-   *   /bgkj:flow[bgkj:id='156@java.lang.String']
-   * </flow-ref>
-   *
-   */
+    /**
+     * This code is picked from yangtools and modified to add type of instance identifier
+     * output of instance identifier something like below for a flow ref composite node of type instance identifier,
+     * which has path arguments with predicates, whose value is of type java.lang.short
+     * <flow-ref xmlns:bgkj="urn:opendaylight:flow:inventory" xmlns:jdlk="urn:opendaylight:inventory">
+     *   /jdlk:nodes/jdlk:node[jdlk:id='openflow:205558455098190@java.lang.String']
+     *   /bgkj:table[bgkj:id='3@java.lang.Short']
+     *   /bgkj:flow[bgkj:id='156@java.lang.String']
+     * </flow-ref>
+     *
+     */

 
 

-  public static String encodeIdentifier(final RandomPrefix prefixes, final YangInstanceIdentifier id) {
-    final StringBuilder textContent = new StringBuilder();
-    for (final PathArgument pathArgument : id.getPathArguments()) {
-      textContent.append('/');
-      textContent.append(prefixes.encodeQName(pathArgument.getNodeType()));
-      if (pathArgument instanceof NodeIdentifierWithPredicates) {
-        final Map<QName, Object> predicates = ((NodeIdentifierWithPredicates) pathArgument).getKeyValues();
+    public static String encodeIdentifier(final RandomPrefix prefixes, final YangInstanceIdentifier id) {
+        final StringBuilder textContent = new StringBuilder();
+        for (final PathArgument pathArgument : id.getPathArguments()) {
+            textContent.append('/');
+            textContent.append(prefixes.encodeQName(pathArgument.getNodeType()));
+            if (pathArgument instanceof NodeIdentifierWithPredicates) {
+                final Map<QName, Object> predicates = ((NodeIdentifierWithPredicates) pathArgument).getKeyValues();

 
 

-        for (final QName keyValue : predicates.keySet()) {
-          final Object value = predicates.get(keyValue);
-          final String type = value.getClass().getName();
-          final String predicateValue = String.valueOf(value);
-          textContent.append('[');
-          textContent.append(prefixes.encodeQName(keyValue));
-          textContent.append("='");
-          textContent.append(predicateValue);
-          textContent.append("@");
-          textContent.append(type);
-          textContent.append("']");
+                for (final QName keyValue : predicates.keySet()) {
+                    final Object value = predicates.get(keyValue);
+                    final String type = value.getClass().getName();
+                    final String predicateValue = String.valueOf(value);
+                    textContent.append('[');
+                    textContent.append(prefixes.encodeQName(keyValue));
+                    textContent.append("='");
+                    textContent.append(predicateValue);
+                    textContent.append("@");
+                    textContent.append(type);
+                    textContent.append("']");
+                }
+            } else if (pathArgument instanceof NodeWithValue) {
+                textContent.append("[.='");
+                textContent.append(((NodeWithValue<?>) pathArgument).getValue());
+                textContent.append("']");
+            }

         }
         }

-      } else if (pathArgument instanceof NodeWithValue) {
-        textContent.append("[.='");
-        textContent.append(((NodeWithValue) pathArgument).getValue());
-        textContent.append("']");
-      }
-    }

 
 

-    return textContent.toString();
-  }
+        return textContent.toString();
+    }

 }
 }

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/PathUtilsTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/PathUtilsTest.java
index 9010f6ea7a7e427fa8feff838dc418bfb46e4ae1..a12f15010c359c791d54f0a86c8140419248f441 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/PathUtilsTest.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/PathUtilsTest.java
@@ -13,6 +13,11 @@ import org.junit.Test;
 import org.opendaylight.controller.cluster.datastore.util.TestModel;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.controller.cluster.datastore.util.TestModel;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;

+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;

 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;


@@ -22,7 +27,7 @@ public class PathUtilsTest {
 
     @Test
     public void toStringNodeIdentifier(){
 
     @Test
     public void toStringNodeIdentifier(){

-        YangInstanceIdentifier.PathArgument pathArgument = nodeIdentifier();
+        PathArgument pathArgument = nodeIdentifier();

 
         String expected = "(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test";
 
 
         String expected = "(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test";
 


@@ -33,7 +38,7 @@ public class PathUtilsTest {
     public void toStringAugmentationIdentifier(){
         String expected = "AugmentationIdentifier{childNames=[(urn:opendaylight:flow:table:statistics?revision=2013-12-15)flow-table-statistics]}";
 
     public void toStringAugmentationIdentifier(){
         String expected = "AugmentationIdentifier{childNames=[(urn:opendaylight:flow:table:statistics?revision=2013-12-15)flow-table-statistics]}";
 

-        YangInstanceIdentifier.PathArgument pathArgument = augmentationIdentifier();
+        PathArgument pathArgument = augmentationIdentifier();

 
         assertEquals(expected, PathUtils.toString(pathArgument));
     }
 
         assertEquals(expected, PathUtils.toString(pathArgument));
     }


@@ -41,7 +46,7 @@ public class PathUtilsTest {
     @Test
     public void toStringNodeWithValue(){
 
     @Test
     public void toStringNodeWithValue(){
 

-        YangInstanceIdentifier.PathArgument pathArgument = nodeWithValue();
+        PathArgument pathArgument = nodeWithValue();

 
         String expected = "(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test[100]";
 
 
         String expected = "(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test[100]";
 


@@ -52,7 +57,7 @@ public class PathUtilsTest {
     @Test
     public void toStringNodeIdentifierWithPredicates(){
 
     @Test
     public void toStringNodeIdentifierWithPredicates(){
 

-        YangInstanceIdentifier.PathArgument pathArgument = nodeIdentifierWithPredicates();
+        PathArgument pathArgument = nodeIdentifierWithPredicates();

 
         String expected = "(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test[{(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)id=100}]";
 
 
         String expected = "(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test[{(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)id=100}]";
 


@@ -93,25 +98,25 @@ public class PathUtilsTest {
 
     }
 
 
     }
 

-    private static YangInstanceIdentifier.NodeIdentifier nodeIdentifier(){
-        return new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME);
+    private static NodeIdentifier nodeIdentifier(){
+        return new NodeIdentifier(TestModel.TEST_QNAME);

     }
 
     }
 

-    private static YangInstanceIdentifier.AugmentationIdentifier augmentationIdentifier(){
+    private static AugmentationIdentifier augmentationIdentifier(){

         Set<QName> childNames = ImmutableSet.of(QNameFactory.create("(urn:opendaylight:flow:table:statistics?revision=2013-12-15)flow-table-statistics"));
 
         Set<QName> childNames = ImmutableSet.of(QNameFactory.create("(urn:opendaylight:flow:table:statistics?revision=2013-12-15)flow-table-statistics"));
 

-        return new YangInstanceIdentifier.AugmentationIdentifier(childNames);
+        return new AugmentationIdentifier(childNames);

     }
 
     }
 

-    private static YangInstanceIdentifier.NodeWithValue nodeWithValue(){
-        return new YangInstanceIdentifier.NodeWithValue(TestModel.TEST_QNAME, Integer.valueOf(100));
+    private static NodeWithValue<?> nodeWithValue(){
+        return new NodeWithValue<>(TestModel.TEST_QNAME, Integer.valueOf(100));

     }
 
     }
 

-    private static YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifierWithPredicates(){
+    private static NodeIdentifierWithPredicates nodeIdentifierWithPredicates(){

         Map<QName, Object> keys = new HashMap<>();
 
         keys.put(TestModel.ID_QNAME, Integer.valueOf(100));
 
         Map<QName, Object> keys = new HashMap<>();
 
         keys.put(TestModel.ID_QNAME, Integer.valueOf(100));
 

-        return new YangInstanceIdentifier.NodeIdentifierWithPredicates(TestModel.TEST_QNAME, keys);
+        return new NodeIdentifierWithPredicates(TestModel.TEST_QNAME, keys);

     }
 }
     }
 }

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/PathArgumentSerializerTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/PathArgumentSerializerTest.java
index fdd2a234345e27c0a864c56a2b0634c709eec6cf..922bc1bfa6828120c219f4609ffcd08d7870349d 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/PathArgumentSerializerTest.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/PathArgumentSerializerTest.java
@@ -16,8 +16,11 @@ import org.junit.rules.ExpectedException;
 import org.opendaylight.controller.cluster.datastore.util.TestModel;
 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.controller.cluster.datastore.util.TestModel;
 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
 import org.opendaylight.yangtools.yang.common.QName;

-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;

 import java.net.URI;
 import java.util.Date;
 import java.util.HashMap;
 import java.net.URI;
 import java.util.Date;
 import java.util.HashMap;


@@ -39,8 +42,7 @@ public class PathArgumentSerializerTest{
         expectedException.expect(NullPointerException.class);
         expectedException.expectMessage("context should not be null");
 
         expectedException.expect(NullPointerException.class);
         expectedException.expectMessage("context should not be null");
 

-        PathArgumentSerializer.serialize(null, mock(
-            YangInstanceIdentifier.PathArgument.class));
+        PathArgumentSerializer.serialize(null, mock(PathArgument.class));

     }
 
     @Test
     }
 
     @Test


@@ -80,7 +82,7 @@ public class PathArgumentSerializerTest{
 
         NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
             .serialize(serializationContext,
 
         NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
             .serialize(serializationContext,

-                new YangInstanceIdentifier.NodeIdentifier(
+                new NodeIdentifier(

                     TestModel.TEST_QNAME));
 
         assertEquals(PathArgumentType.NODE_IDENTIFIER.ordinal(), actual.getIntType());
                     TestModel.TEST_QNAME));
 
         assertEquals(PathArgumentType.NODE_IDENTIFIER.ordinal(), actual.getIntType());


@@ -101,7 +103,7 @@ public class PathArgumentSerializerTest{
 
         NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
             .serialize(serializationContext,
 
         NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
             .serialize(serializationContext,

-                new YangInstanceIdentifier.NodeWithValue(
+                new NodeWithValue<>(

                     TestModel.TEST_QNAME, "foo"));
 
         assertEquals(PathArgumentType.NODE_IDENTIFIER_WITH_VALUE.ordinal(), actual.getIntType());
                     TestModel.TEST_QNAME, "foo"));
 
         assertEquals(PathArgumentType.NODE_IDENTIFIER_WITH_VALUE.ordinal(), actual.getIntType());


@@ -134,8 +136,7 @@ public class PathArgumentSerializerTest{
 
         NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
             .serialize(serializationContext,
 
         NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
             .serialize(serializationContext,

-                new YangInstanceIdentifier.NodeIdentifierWithPredicates(
-                    TestModel.TEST_QNAME, predicates));
+                new NodeIdentifierWithPredicates(TestModel.TEST_QNAME, predicates));

 
         assertEquals(PathArgumentType.NODE_IDENTIFIER_WITH_PREDICATES.ordinal(), actual.getIntType());
         assertEquals(5, actual.getNodeType().getLocalName());
 
         assertEquals(PathArgumentType.NODE_IDENTIFIER_WITH_PREDICATES.ordinal(), actual.getIntType());
         assertEquals(5, actual.getNodeType().getLocalName());


@@ -161,8 +162,7 @@ public class PathArgumentSerializerTest{
 
         NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
             .serialize(serializationContext,
 
         NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
             .serialize(serializationContext,

-                new YangInstanceIdentifier.AugmentationIdentifier(
-                    ImmutableSet.of(TestModel.TEST_QNAME)));
+                new AugmentationIdentifier(ImmutableSet.of(TestModel.TEST_QNAME)));

 
         assertEquals(PathArgumentType.AUGMENTATION_IDENTIFIER.ordinal(), actual.getIntType());
 
 
         assertEquals(PathArgumentType.AUGMENTATION_IDENTIFIER.ordinal(), actual.getIntType());
 


@@ -190,11 +190,9 @@ public class PathArgumentSerializerTest{
         nodeBuilder.addCode(TestModel.TEST_QNAME.getFormattedRevision());
         nodeBuilder.addCode(TestModel.TEST_QNAME.getLocalName());
 
         nodeBuilder.addCode(TestModel.TEST_QNAME.getFormattedRevision());
         nodeBuilder.addCode(TestModel.TEST_QNAME.getLocalName());
 

-        YangInstanceIdentifier.PathArgument pathArgument =
-            NormalizedNodeSerializer
-                .deSerialize(nodeBuilder.build(), pathBuilder.build());
+        PathArgument pathArgument = NormalizedNodeSerializer.deSerialize(nodeBuilder.build(), pathBuilder.build());

 
 

-        assertEquals(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME), pathArgument);
+        assertEquals(new NodeIdentifier(TestModel.TEST_QNAME), pathArgument);

 
     }
 
 
     }
 


@@ -218,11 +216,9 @@ public class PathArgumentSerializerTest{
         nodeBuilder.addCode(TestModel.TEST_QNAME.getFormattedRevision());
         nodeBuilder.addCode(TestModel.TEST_QNAME.getLocalName());
 
         nodeBuilder.addCode(TestModel.TEST_QNAME.getFormattedRevision());
         nodeBuilder.addCode(TestModel.TEST_QNAME.getLocalName());
 

-        YangInstanceIdentifier.PathArgument pathArgument =
-            NormalizedNodeSerializer
-                .deSerialize(nodeBuilder.build(), pathBuilder.build());
+        PathArgument pathArgument = NormalizedNodeSerializer.deSerialize(nodeBuilder.build(), pathBuilder.build());

 
 

-        assertEquals(new YangInstanceIdentifier.NodeWithValue(TestModel.TEST_QNAME, "foo"), pathArgument);
+        assertEquals(new NodeWithValue<>(TestModel.TEST_QNAME, "foo"), pathArgument);

 
     }
     @Test
 
     }
     @Test


@@ -244,11 +240,9 @@ public class PathArgumentSerializerTest{
         nodeBuilder.addCode(TestModel.TEST_QNAME.getFormattedRevision());
         nodeBuilder.addCode(TestModel.TEST_QNAME.getLocalName());
 
         nodeBuilder.addCode(TestModel.TEST_QNAME.getFormattedRevision());
         nodeBuilder.addCode(TestModel.TEST_QNAME.getLocalName());
 

-        YangInstanceIdentifier.PathArgument pathArgument =
-            NormalizedNodeSerializer
-                .deSerialize(nodeBuilder.build(), pathBuilder.build());
+        PathArgument pathArgument = NormalizedNodeSerializer.deSerialize(nodeBuilder.build(), pathBuilder.build());

 
 

-        assertEquals(new YangInstanceIdentifier.NodeIdentifierWithPredicates(TestModel.TEST_QNAME,
+        assertEquals(new NodeIdentifierWithPredicates(TestModel.TEST_QNAME,

             ImmutableMap.<QName, Object>of(TestModel.TEST_QNAME, "foo")), pathArgument);
 
     }
             ImmutableMap.<QName, Object>of(TestModel.TEST_QNAME, "foo")), pathArgument);
 
     }


@@ -269,14 +263,8 @@ public class PathArgumentSerializerTest{
         nodeBuilder.addCode(TestModel.TEST_QNAME.getFormattedRevision());
         nodeBuilder.addCode(TestModel.TEST_QNAME.getLocalName());
 
         nodeBuilder.addCode(TestModel.TEST_QNAME.getFormattedRevision());
         nodeBuilder.addCode(TestModel.TEST_QNAME.getLocalName());
 

-        YangInstanceIdentifier.PathArgument pathArgument =
-            NormalizedNodeSerializer
-                .deSerialize(nodeBuilder.build(), pathBuilder.build());
-
-        assertEquals(new YangInstanceIdentifier.AugmentationIdentifier(ImmutableSet.of(TestModel.TEST_QNAME)), pathArgument);
+        PathArgument pathArgument = NormalizedNodeSerializer.deSerialize(nodeBuilder.build(), pathBuilder.build());

 
 

+        assertEquals(new AugmentationIdentifier(ImmutableSet.of(TestModel.TEST_QNAME)), pathArgument);

     }
     }

-
-
-

 }
 }

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeStreamReaderWriterTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeStreamReaderWriterTest.java
index 9985c69a2b0422f0a3e18458ce6a9ebca28d13c1..9803df937a721ce3d41d6b9bf12941852601e3ed 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeStreamReaderWriterTest.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeStreamReaderWriterTest.java
@@ -19,6 +19,7 @@ import org.opendaylight.controller.cluster.datastore.util.TestModel;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;

+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;

 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;


@@ -69,26 +70,23 @@ public class NormalizedNodeStreamReaderWriterTest {
     private static NormalizedNode<?, ?> createTestContainer() {
         byte[] bytes1 = {1,2,3};
         LeafSetEntryNode<Object> entry1 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
     private static NormalizedNode<?, ?> createTestContainer() {
         byte[] bytes1 = {1,2,3};
         LeafSetEntryNode<Object> entry1 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(

-                new YangInstanceIdentifier.NodeWithValue(TestModel.BINARY_LEAF_LIST_QNAME, bytes1)).
-                withValue(bytes1).build();
+                new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes1)).withValue(bytes1).build();

 
         byte[] bytes2 = {};
         LeafSetEntryNode<Object> entry2 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
 
         byte[] bytes2 = {};
         LeafSetEntryNode<Object> entry2 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(

-                new YangInstanceIdentifier.NodeWithValue(TestModel.BINARY_LEAF_LIST_QNAME, bytes2)).
-                withValue(bytes2).build();
+                new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes2)).withValue(bytes2).build();

 
         LeafSetEntryNode<Object> entry3 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
 
         LeafSetEntryNode<Object> entry3 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(

-                new YangInstanceIdentifier.NodeWithValue(TestModel.BINARY_LEAF_LIST_QNAME, null)).
-                withValue(null).build();
+                new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, null)).withValue(null).build();

 
 
         return TestModel.createBaseTestContainerBuilder().
                 withChild(ImmutableLeafSetNodeBuilder.create().withNodeIdentifier(
 
 
         return TestModel.createBaseTestContainerBuilder().
                 withChild(ImmutableLeafSetNodeBuilder.create().withNodeIdentifier(

-                        new YangInstanceIdentifier.NodeIdentifier(TestModel.BINARY_LEAF_LIST_QNAME)).
+                        new NodeIdentifier(TestModel.BINARY_LEAF_LIST_QNAME)).

                         withChild(entry1).withChild(entry2).withChild(entry3).build()).
                 withChild(ImmutableNodes.leafNode(TestModel.SOME_BINARY_DATA_QNAME, new byte[]{1,2,3,4})).
                 withChild(Builders.orderedMapBuilder().
                         withChild(entry1).withChild(entry2).withChild(entry3).build()).
                 withChild(ImmutableNodes.leafNode(TestModel.SOME_BINARY_DATA_QNAME, new byte[]{1,2,3,4})).
                 withChild(Builders.orderedMapBuilder().

-                      withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.ORDERED_LIST_QNAME)).
+                      withNodeIdentifier(new NodeIdentifier(TestModel.ORDERED_LIST_QNAME)).

                       withChild(ImmutableNodes.mapEntry(TestModel.ORDERED_LIST_ENTRY_QNAME,
                               TestModel.ID_QNAME, 11)).build()).
                 build();
                       withChild(ImmutableNodes.mapEntry(TestModel.ORDERED_LIST_ENTRY_QNAME,
                               TestModel.ID_QNAME, 11)).build()).
                 build();

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/ValueTypesTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/ValueTypesTest.java
index be521ef8ee5df30814bcd87fa403375b87b2a552..ff1ddad7056d18b713f350a2a45d9c06caea95f3 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/ValueTypesTest.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/ValueTypesTest.java
@@ -19,7 +19,7 @@ public class ValueTypesTest {
         assertEquals(ValueTypes.STRING_BYTES_TYPE, ValueTypes.getSerializableType(largeString));
     }
 
         assertEquals(ValueTypes.STRING_BYTES_TYPE, ValueTypes.getSerializableType(largeString));
     }
 

-    private String largeString(int minSize){
+    private static String largeString(int minSize){

         final int pow = (int) (Math.log(minSize * 2) / Math.log(2));
         String s = "X";
         for(int i=0;i<pow;i++){
         final int pow = (int) (Math.log(minSize * 2) / Math.log(2));
         String s = "X";
         for(int i=0;i<pow;i++){

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePrunerTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePrunerTest.java
index 2ee859466adffdc4a76de1e9f848d29a9a152b8c..57fbd99bcd5643e618cadccd803131a44f570e63 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePrunerTest.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePrunerTest.java
@@ -32,6 +32,10 @@ import org.opendaylight.controller.cluster.datastore.node.utils.NormalizedNodeVi
 import org.opendaylight.controller.cluster.datastore.util.TestModel;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.controller.cluster.datastore.util.TestModel;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;

+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;

 import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
 import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;


@@ -159,13 +163,13 @@ public class NormalizedNodePrunerTest {
 
             @Override
             public void visitNode(int level, String parentPath, NormalizedNode<?, ?> normalizedNode) {
 
             @Override
             public void visitNode(int level, String parentPath, NormalizedNode<?, ?> normalizedNode) {

-                if(!(normalizedNode.getIdentifier() instanceof YangInstanceIdentifier.AugmentationIdentifier)) {
+                if(!(normalizedNode.getIdentifier() instanceof AugmentationIdentifier)) {

                     if (normalizedNode.getIdentifier().getNodeType().getNamespace().toString().contains(namespaceFilter)) {
                         count.incrementAndGet();
                     }
                 }
             }
                     if (normalizedNode.getIdentifier().getNodeType().getNamespace().toString().contains(namespaceFilter)) {
                         count.incrementAndGet();
                     }
                 }
             }

-        }).navigate(YangInstanceIdentifier.builder().build().toString(), normalizedNode);
+        }).navigate(YangInstanceIdentifier.EMPTY.toString(), normalizedNode);

 
         return count.get();
     }
 
         return count.get();
     }


@@ -173,7 +177,7 @@ public class NormalizedNodePrunerTest {
     @Test
     public void testLeafNodeHasNoParent() throws IOException {
         NormalizedNode<?, ?> input = Builders.leafBuilder().withNodeIdentifier(
     @Test
     public void testLeafNodeHasNoParent() throws IOException {
         NormalizedNode<?, ?> input = Builders.leafBuilder().withNodeIdentifier(

-                new YangInstanceIdentifier.NodeIdentifier(TestModel.DESC_QNAME)).withValue("test").build();
+                new NodeIdentifier(TestModel.DESC_QNAME)).withValue("test").build();

         NormalizedNodeWriter.forStreamWriter(prunerFullSchema).write(input);
 
         NormalizedNode<?, ?> actual = prunerFullSchema.normalizedNode();
         NormalizedNodeWriter.forStreamWriter(prunerFullSchema).write(input);
 
         NormalizedNode<?, ?> actual = prunerFullSchema.normalizedNode();


@@ -183,9 +187,9 @@ public class NormalizedNodePrunerTest {
     @Test
     public void testLeafNodeHasParent() throws IOException {
         LeafNode<Object> child = Builders.leafBuilder().withNodeIdentifier(
     @Test
     public void testLeafNodeHasParent() throws IOException {
         LeafNode<Object> child = Builders.leafBuilder().withNodeIdentifier(

-                new YangInstanceIdentifier.NodeIdentifier(TestModel.DESC_QNAME)).withValue("test").build();
+                new NodeIdentifier(TestModel.DESC_QNAME)).withValue("test").build();

         NormalizedNode<?, ?> input = Builders.containerBuilder().withNodeIdentifier(
         NormalizedNode<?, ?> input = Builders.containerBuilder().withNodeIdentifier(

-                new YangInstanceIdentifier.NodeIdentifier(TestModel.AUG_CONT_QNAME)).withChild(child).build();
+                new NodeIdentifier(TestModel.AUG_CONT_QNAME)).withChild(child).build();

         NormalizedNodeWriter.forStreamWriter(prunerFullSchema).write(input);
 
         NormalizedNode<?, ?> actual = prunerFullSchema.normalizedNode();
         NormalizedNodeWriter.forStreamWriter(prunerFullSchema).write(input);
 
         NormalizedNode<?, ?> actual = prunerFullSchema.normalizedNode();


@@ -195,14 +199,14 @@ public class NormalizedNodePrunerTest {
     @Test
     public void testLeafNodeSchemaMissing() throws IOException {
         prunerNoAugSchema.stack().push(normalizedNodeBuilderWrapper);
     @Test
     public void testLeafNodeSchemaMissing() throws IOException {
         prunerNoAugSchema.stack().push(normalizedNodeBuilderWrapper);

-        prunerNoAugSchema.leafNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.AUG_CONT_QNAME), mock(Object.class));
+        prunerNoAugSchema.leafNode(new NodeIdentifier(TestModel.AUG_CONT_QNAME), mock(Object.class));

         verify(normalizedNodeContainerBuilder, never()).addChild(any(NormalizedNode.class));
     }
 
     @Test
     public void testLeafSetEntryNodeHasNoParent() throws IOException {
         NormalizedNode<?, ?> input = Builders.leafSetEntryBuilder().withValue("test").withNodeIdentifier(
         verify(normalizedNodeContainerBuilder, never()).addChild(any(NormalizedNode.class));
     }
 
     @Test
     public void testLeafSetEntryNodeHasNoParent() throws IOException {
         NormalizedNode<?, ?> input = Builders.leafSetEntryBuilder().withValue("test").withNodeIdentifier(

-                new YangInstanceIdentifier.NodeWithValue<>(TestModel.FAMILY_QNAME, "test")).build();
+                new NodeWithValue<>(TestModel.FAMILY_QNAME, "test")).build();

         NormalizedNodeWriter.forStreamWriter(prunerFullSchema).write(input);
 
         NormalizedNode<?, ?> actual = prunerFullSchema.normalizedNode();
         NormalizedNodeWriter.forStreamWriter(prunerFullSchema).write(input);
 
         NormalizedNode<?, ?> actual = prunerFullSchema.normalizedNode();


@@ -212,9 +216,9 @@ public class NormalizedNodePrunerTest {
     @Test
     public void testLeafSetEntryNodeHasParent() throws IOException {
         LeafSetEntryNode<Object> child = Builders.leafSetEntryBuilder().withValue("test").withNodeIdentifier(
     @Test
     public void testLeafSetEntryNodeHasParent() throws IOException {
         LeafSetEntryNode<Object> child = Builders.leafSetEntryBuilder().withValue("test").withNodeIdentifier(

-                new YangInstanceIdentifier.NodeWithValue<>(TestModel.FAMILY_QNAME, "test")).build();
+                new NodeWithValue<>(TestModel.FAMILY_QNAME, "test")).build();

         NormalizedNode<?, ?> input = Builders.leafSetBuilder().withNodeIdentifier(
         NormalizedNode<?, ?> input = Builders.leafSetBuilder().withNodeIdentifier(

-                new YangInstanceIdentifier.NodeIdentifier(TestModel.FAMILY_QNAME)).withChild(child).build();
+                new NodeIdentifier(TestModel.FAMILY_QNAME)).withChild(child).build();

         NormalizedNodeWriter.forStreamWriter(prunerFullSchema).write(input);
 
         NormalizedNode<?, ?> actual = prunerFullSchema.normalizedNode();
         NormalizedNodeWriter.forStreamWriter(prunerFullSchema).write(input);
 
         NormalizedNode<?, ?> actual = prunerFullSchema.normalizedNode();


@@ -223,7 +227,7 @@ public class NormalizedNodePrunerTest {
 
     @Test
     public void testLeafSetEntryNodeSchemaMissing() throws IOException {
 
     @Test
     public void testLeafSetEntryNodeSchemaMissing() throws IOException {

-        doReturn(new YangInstanceIdentifier.NodeIdentifier(TestModel.AUG_CONT_QNAME)).when(normalizedNodeBuilderWrapper).identifier();
+        doReturn(new NodeIdentifier(TestModel.AUG_CONT_QNAME)).when(normalizedNodeBuilderWrapper).identifier();

 
         prunerNoAugSchema.stack().push(normalizedNodeBuilderWrapper);
         prunerNoAugSchema.leafSetEntryNode(TestModel.AUG_CONT_QNAME, "");
 
         prunerNoAugSchema.stack().push(normalizedNodeBuilderWrapper);
         prunerNoAugSchema.leafSetEntryNode(TestModel.AUG_CONT_QNAME, "");


@@ -234,7 +238,7 @@ public class NormalizedNodePrunerTest {
     @Test
     public void testAnyXMLNodeHasNoParent() throws IOException {
         NormalizedNode<?, ?> input = Builders.anyXmlBuilder().withNodeIdentifier(
     @Test
     public void testAnyXMLNodeHasNoParent() throws IOException {
         NormalizedNode<?, ?> input = Builders.anyXmlBuilder().withNodeIdentifier(

-                new YangInstanceIdentifier.NodeIdentifier(TestModel.CHILD_NAME_QNAME)).
+                new NodeIdentifier(TestModel.CHILD_NAME_QNAME)).

                     withValue(mock(DOMSource.class)).build();
         NormalizedNodeWriter.forStreamWriter(prunerFullSchema).write(input);
 
                     withValue(mock(DOMSource.class)).build();
         NormalizedNodeWriter.forStreamWriter(prunerFullSchema).write(input);
 


@@ -245,10 +249,10 @@ public class NormalizedNodePrunerTest {
     @Test
     public void testAnyXMLNodeHasParent() throws IOException {
         AnyXmlNode child = Builders.anyXmlBuilder().withNodeIdentifier(
     @Test
     public void testAnyXMLNodeHasParent() throws IOException {
         AnyXmlNode child = Builders.anyXmlBuilder().withNodeIdentifier(

-                new YangInstanceIdentifier.NodeIdentifier(TestModel.CHILD_NAME_QNAME)).
+                new NodeIdentifier(TestModel.CHILD_NAME_QNAME)).

                     withValue(mock(DOMSource.class)).build();
         NormalizedNode<?, ?> input = Builders.containerBuilder().withNodeIdentifier(
                     withValue(mock(DOMSource.class)).build();
         NormalizedNode<?, ?> input = Builders.containerBuilder().withNodeIdentifier(

-                new YangInstanceIdentifier.NodeIdentifier(TestModel.AUG_CONT_QNAME)).withChild(child).build();
+                new NodeIdentifier(TestModel.AUG_CONT_QNAME)).withChild(child).build();

         NormalizedNodeWriter.forStreamWriter(prunerFullSchema).write(input);
 
         NormalizedNode<?, ?> actual = prunerFullSchema.normalizedNode();
         NormalizedNodeWriter.forStreamWriter(prunerFullSchema).write(input);
 
         NormalizedNode<?, ?> actual = prunerFullSchema.normalizedNode();


@@ -258,7 +262,7 @@ public class NormalizedNodePrunerTest {
     @Test
     public void testAnyXmlNodeSchemaMissing() throws IOException {
         prunerNoAugSchema.stack().push(normalizedNodeBuilderWrapper);
     @Test
     public void testAnyXmlNodeSchemaMissing() throws IOException {
         prunerNoAugSchema.stack().push(normalizedNodeBuilderWrapper);

-        prunerNoAugSchema.anyxmlNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.AUG_CONT_QNAME), mock(DOMSource.class));
+        prunerNoAugSchema.anyxmlNode(new NodeIdentifier(TestModel.AUG_CONT_QNAME), mock(DOMSource.class));

 
         verify(normalizedNodeContainerBuilder, never()).addChild(any(NormalizedNode.class));
     }
 
         verify(normalizedNodeContainerBuilder, never()).addChild(any(NormalizedNode.class));
     }


@@ -266,7 +270,7 @@ public class NormalizedNodePrunerTest {
 
     @Test
     public void testLeafSetPushesBuilderToStack() throws IOException {
 
     @Test
     public void testLeafSetPushesBuilderToStack() throws IOException {

-        prunerFullSchema.startLeafSet(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10);
+        prunerFullSchema.startLeafSet(new NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10);

 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());
 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());


@@ -275,7 +279,7 @@ public class NormalizedNodePrunerTest {
 
     @Test
     public void testStartContainerNodePushesBuilderToStack() throws IOException {
 
     @Test
     public void testStartContainerNodePushesBuilderToStack() throws IOException {

-        prunerFullSchema.startContainerNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10);
+        prunerFullSchema.startContainerNode(new NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10);

 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());
 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());


@@ -284,7 +288,7 @@ public class NormalizedNodePrunerTest {
 
     @Test
     public void testStartUnkeyedListPushesBuilderToStack() throws IOException {
 
     @Test
     public void testStartUnkeyedListPushesBuilderToStack() throws IOException {

-        prunerFullSchema.startUnkeyedList(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10);
+        prunerFullSchema.startUnkeyedList(new NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10);

 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());
 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());


@@ -293,7 +297,7 @@ public class NormalizedNodePrunerTest {
 
     @Test
     public void testStartUnkeyedListItemPushesBuilderToStack() throws IOException {
 
     @Test
     public void testStartUnkeyedListItemPushesBuilderToStack() throws IOException {

-        prunerFullSchema.startUnkeyedListItem(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10);
+        prunerFullSchema.startUnkeyedListItem(new NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10);

 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());
 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());


@@ -302,7 +306,7 @@ public class NormalizedNodePrunerTest {
 
     @Test
     public void testStartMapNodePushesBuilderToStack() throws IOException {
 
     @Test
     public void testStartMapNodePushesBuilderToStack() throws IOException {

-        prunerFullSchema.startMapNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10);
+        prunerFullSchema.startMapNode(new NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10);

 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());
 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());


@@ -312,7 +316,7 @@ public class NormalizedNodePrunerTest {
     @Test
     public void testStartMapEntryNodePushesBuilderToStack() throws IOException {
         prunerFullSchema.startMapEntryNode(
     @Test
     public void testStartMapEntryNodePushesBuilderToStack() throws IOException {
         prunerFullSchema.startMapEntryNode(

-                new YangInstanceIdentifier.NodeIdentifierWithPredicates(TestModel.BOOLEAN_LEAF_QNAME,
+                new NodeIdentifierWithPredicates(TestModel.BOOLEAN_LEAF_QNAME,

                         ImmutableMap.<QName, Object>of(TestModel.BOOLEAN_LEAF_QNAME, "value")), 10);
 
         assertEquals(1, prunerFullSchema.stack().size());
                         ImmutableMap.<QName, Object>of(TestModel.BOOLEAN_LEAF_QNAME, "value")), 10);
 
         assertEquals(1, prunerFullSchema.stack().size());


@@ -322,7 +326,7 @@ public class NormalizedNodePrunerTest {
 
     @Test
     public void testStartOrderedMapNodePushesBuilderToStack() throws IOException {
 
     @Test
     public void testStartOrderedMapNodePushesBuilderToStack() throws IOException {

-        prunerFullSchema.startOrderedMapNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10);
+        prunerFullSchema.startOrderedMapNode(new NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10);

 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());
 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());


@@ -331,7 +335,7 @@ public class NormalizedNodePrunerTest {
 
     @Test
     public void testStartChoiceNodePushesBuilderToStack() throws IOException {
 
     @Test
     public void testStartChoiceNodePushesBuilderToStack() throws IOException {

-        prunerFullSchema.startChoiceNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10);
+        prunerFullSchema.startChoiceNode(new NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10);

 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());
 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());


@@ -340,7 +344,7 @@ public class NormalizedNodePrunerTest {
 
     @Test
     public void testStartAugmentationPushesBuilderToStack() throws IOException {
 
     @Test
     public void testStartAugmentationPushesBuilderToStack() throws IOException {

-        prunerFullSchema.startAugmentationNode(new YangInstanceIdentifier.AugmentationIdentifier(ImmutableSet.of(TestModel.AUG_CONT_QNAME)));
+        prunerFullSchema.startAugmentationNode(new AugmentationIdentifier(ImmutableSet.of(TestModel.AUG_CONT_QNAME)));

 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());
 
         assertEquals(1, prunerFullSchema.stack().size());
         assertNotNull(prunerFullSchema.stack().peek());


@@ -361,7 +365,7 @@ public class NormalizedNodePrunerTest {
 
     @Test
     public void testEndNodeSchemaMissing() throws IOException {
 
     @Test
     public void testEndNodeSchemaMissing() throws IOException {

-        doReturn(new YangInstanceIdentifier.NodeIdentifier(TestModel.AUG_CONT_QNAME)).when(normalizedNodeBuilderWrapper).identifier();
+        doReturn(new NodeIdentifier(TestModel.AUG_CONT_QNAME)).when(normalizedNodeBuilderWrapper).identifier();

 
         prunerNoAugSchema.stack().push(normalizedNodeBuilderWrapper);
         prunerNoAugSchema.endNode();
 
         prunerNoAugSchema.stack().push(normalizedNodeBuilderWrapper);
         prunerNoAugSchema.endNode();


@@ -383,26 +387,25 @@ public class NormalizedNodePrunerTest {
     private static NormalizedNode<?, ?> createTestContainer() {
         byte[] bytes1 = {1,2,3};
         LeafSetEntryNode<Object> entry1 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
     private static NormalizedNode<?, ?> createTestContainer() {
         byte[] bytes1 = {1,2,3};
         LeafSetEntryNode<Object> entry1 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(

-                new YangInstanceIdentifier.NodeWithValue(TestModel.BINARY_LEAF_LIST_QNAME, bytes1)).
+                new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes1)).

                 withValue(bytes1).build();
 
         byte[] bytes2 = {};
         LeafSetEntryNode<Object> entry2 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
                 withValue(bytes1).build();
 
         byte[] bytes2 = {};
         LeafSetEntryNode<Object> entry2 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(

-                new YangInstanceIdentifier.NodeWithValue(TestModel.BINARY_LEAF_LIST_QNAME, bytes2)).
+                new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes2)).

                 withValue(bytes2).build();
 
         LeafSetEntryNode<Object> entry3 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
                 withValue(bytes2).build();
 
         LeafSetEntryNode<Object> entry3 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(

-                new YangInstanceIdentifier.NodeWithValue(TestModel.BINARY_LEAF_LIST_QNAME, null)).
-                withValue(null).build();
+                new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, null)).withValue(null).build();

 
 
         return TestModel.createBaseTestContainerBuilder().
                 withChild(ImmutableLeafSetNodeBuilder.create().withNodeIdentifier(
 
 
         return TestModel.createBaseTestContainerBuilder().
                 withChild(ImmutableLeafSetNodeBuilder.create().withNodeIdentifier(

-                        new YangInstanceIdentifier.NodeIdentifier(TestModel.BINARY_LEAF_LIST_QNAME)).
+                        new NodeIdentifier(TestModel.BINARY_LEAF_LIST_QNAME)).

                         withChild(entry1).withChild(entry2).withChild(entry3).build()).
                 withChild(ImmutableNodes.leafNode(TestModel.SOME_BINARY_DATA_QNAME, new byte[]{1, 2, 3, 4})).
                 withChild(Builders.orderedMapBuilder().
                         withChild(entry1).withChild(entry2).withChild(entry3).build()).
                 withChild(ImmutableNodes.leafNode(TestModel.SOME_BINARY_DATA_QNAME, new byte[]{1, 2, 3, 4})).
                 withChild(Builders.orderedMapBuilder().

-                        withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.ORDERED_LIST_QNAME)).
+                        withNodeIdentifier(new NodeIdentifier(TestModel.ORDERED_LIST_QNAME)).

                         withChild(ImmutableNodes.mapEntry(TestModel.ORDERED_LIST_ENTRY_QNAME,
                                 TestModel.ID_QNAME, 11)).build()).
                 build();
                         withChild(ImmutableNodes.mapEntry(TestModel.ORDERED_LIST_ENTRY_QNAME,
                                 TestModel.ID_QNAME, 11)).build()).
                 build();

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/util/InstanceIdentifierUtilsTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/util/InstanceIdentifierUtilsTest.java
index 8557dda4bb0787e572623afc0ddfcfb958973159..18b577f9d9e19658b3eaad8720c3b55eb258930c 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/util/InstanceIdentifierUtilsTest.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/util/InstanceIdentifierUtilsTest.java
@@ -23,13 +23,13 @@ import java.util.List;
 
 public class InstanceIdentifierUtilsTest {
 
 
 public class InstanceIdentifierUtilsTest {
 

-    private static QName TEST_QNAME = QName
+    private static final QName TEST_QNAME = QName

             .create("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test");
             .create("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test");

-    private static QName NODE_WITH_VALUE_QNAME = QName
+    private static final QName NODE_WITH_VALUE_QNAME = QName

             .create("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)value");
             .create("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)value");

-    private static QName NODE_WITH_PREDICATES_QNAME = QName
+    private static final QName NODE_WITH_PREDICATES_QNAME = QName

             .create("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)pred");
             .create("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)pred");

-    private static QName NAME_QNAME = QName
+    private static final QName NAME_QNAME = QName

             .create("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)name");
 
     @Test
             .create("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)name");
 
     @Test


@@ -64,7 +64,7 @@ public class InstanceIdentifierUtilsTest {
         YangInstanceIdentifier.PathArgument p1 = new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME);
 
         YangInstanceIdentifier.PathArgument p2 =
         YangInstanceIdentifier.PathArgument p1 = new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME);
 
         YangInstanceIdentifier.PathArgument p2 =

-                new YangInstanceIdentifier.NodeWithValue(NODE_WITH_VALUE_QNAME, value);
+                new YangInstanceIdentifier.NodeWithValue<>(NODE_WITH_VALUE_QNAME, value);

 
         List<YangInstanceIdentifier.PathArgument> arguments = new ArrayList<>();
 
 
         List<YangInstanceIdentifier.PathArgument> arguments = new ArrayList<>();
 


@@ -137,7 +137,7 @@ public class InstanceIdentifierUtilsTest {
         List<YangInstanceIdentifier.PathArgument> arguments =
                                                 Arrays.<YangInstanceIdentifier.PathArgument>asList(
                 new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME),
         List<YangInstanceIdentifier.PathArgument> arguments =
                                                 Arrays.<YangInstanceIdentifier.PathArgument>asList(
                 new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME),

-                new YangInstanceIdentifier.NodeWithValue(NODE_WITH_VALUE_QNAME, 1),
+                new YangInstanceIdentifier.NodeWithValue<>(NODE_WITH_VALUE_QNAME, 1),

                 new YangInstanceIdentifier.NodeIdentifierWithPredicates(
                         NODE_WITH_PREDICATES_QNAME, NAME_QNAME, 2));
 
                 new YangInstanceIdentifier.NodeIdentifierWithPredicates(
                         NODE_WITH_PREDICATES_QNAME, NAME_QNAME, 2));
 

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/util/TestModel.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/util/TestModel.java
index 7df43e0adcdd8865a2e3e8c1b508faa18237ba8f..99b8cf8ff52d32b8d4973f0d0c0ac550c8e5f47a 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/util/TestModel.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/util/TestModel.java
@@ -25,6 +25,10 @@ import java.util.Map;
 import java.util.Set;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import java.util.Set;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;

+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;

 import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
 import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;


@@ -240,33 +244,33 @@ public class TestModel {
         return ImmutableContainerNodeBuilder
                 .create()
                 .withNodeIdentifier(
         return ImmutableContainerNodeBuilder
                 .create()
                 .withNodeIdentifier(

-                        new YangInstanceIdentifier.NodeIdentifier(schemaContext.getQName()))
+                        new NodeIdentifier(schemaContext.getQName()))

                 .withChild(createTestContainer()).build();
 
     }
 
                 .withChild(createTestContainer()).build();
 
     }
 

-    public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> createBaseTestContainerBuilder() {
+    public static DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> createBaseTestContainerBuilder() {

         // Create a list of shoes
         // This is to test leaf list entry
         final LeafSetEntryNode<Object> nike =
                 ImmutableLeafSetEntryNodeBuilder
                         .create()
                         .withNodeIdentifier(
         // Create a list of shoes
         // This is to test leaf list entry
         final LeafSetEntryNode<Object> nike =
                 ImmutableLeafSetEntryNodeBuilder
                         .create()
                         .withNodeIdentifier(

-                                new YangInstanceIdentifier.NodeWithValue(QName.create(
+                                new NodeWithValue<>(QName.create(

                                         TEST_QNAME, "shoe"), "nike")).withValue("nike").build();
 
         final LeafSetEntryNode<Object> puma =
                 ImmutableLeafSetEntryNodeBuilder
                         .create()
                         .withNodeIdentifier(
                                         TEST_QNAME, "shoe"), "nike")).withValue("nike").build();
 
         final LeafSetEntryNode<Object> puma =
                 ImmutableLeafSetEntryNodeBuilder
                         .create()
                         .withNodeIdentifier(

-                                new YangInstanceIdentifier.NodeWithValue(QName.create(
+                                new NodeWithValue<>(QName.create(

                                         TEST_QNAME, "shoe"), "puma")).withValue("puma").build();
 
         final LeafSetNode<Object> shoes =
                 ImmutableLeafSetNodeBuilder
                         .create()
                         .withNodeIdentifier(
                                         TEST_QNAME, "shoe"), "puma")).withValue("puma").build();
 
         final LeafSetNode<Object> shoes =
                 ImmutableLeafSetNodeBuilder
                         .create()
                         .withNodeIdentifier(

-                                new YangInstanceIdentifier.NodeIdentifier(QName.create(
+                                new NodeIdentifier(QName.create(

                                         TEST_QNAME, "shoe"))).withChild(nike).withChild(puma)
                         .build();
 
                                         TEST_QNAME, "shoe"))).withChild(nike).withChild(puma)
                         .build();
 


@@ -276,7 +280,7 @@ public class TestModel {
                 ImmutableLeafSetEntryNodeBuilder
                         .create()
                         .withNodeIdentifier(
                 ImmutableLeafSetEntryNodeBuilder
                         .create()
                         .withNodeIdentifier(

-                                new YangInstanceIdentifier.NodeWithValue(QName.create(
+                                new NodeWithValue<>(QName.create(

                                         TEST_QNAME, "capability"), DESC_QNAME))
                         .withValue(DESC_QNAME).build();
 
                                         TEST_QNAME, "capability"), DESC_QNAME))
                         .withValue(DESC_QNAME).build();
 


@@ -284,14 +288,14 @@ public class TestModel {
                 ImmutableLeafSetNodeBuilder
                         .create()
                         .withNodeIdentifier(
                 ImmutableLeafSetNodeBuilder
                         .create()
                         .withNodeIdentifier(

-                                new YangInstanceIdentifier.NodeIdentifier(QName.create(
+                                new NodeIdentifier(QName.create(

                                         TEST_QNAME, "capability"))).withChild(cap1).build();
 
         ContainerNode switchFeatures =
                 ImmutableContainerNodeBuilder
                         .create()
                         .withNodeIdentifier(
                                         TEST_QNAME, "capability"))).withChild(cap1).build();
 
         ContainerNode switchFeatures =
                 ImmutableContainerNodeBuilder
                         .create()
                         .withNodeIdentifier(

-                                new YangInstanceIdentifier.NodeIdentifier(SWITCH_FEATURES_QNAME))
+                                new NodeIdentifier(SWITCH_FEATURES_QNAME))

                         .withChild(capabilities).build();
 
         // Create a leaf list with numbers
                         .withChild(capabilities).build();
 
         // Create a leaf list with numbers


@@ -299,19 +303,19 @@ public class TestModel {
                 ImmutableLeafSetEntryNodeBuilder
                         .create()
                         .withNodeIdentifier(
                 ImmutableLeafSetEntryNodeBuilder
                         .create()
                         .withNodeIdentifier(

-                                (new YangInstanceIdentifier.NodeWithValue(QName.create(
+                                (new NodeWithValue<>(QName.create(

                                         TEST_QNAME, "number"), 5))).withValue(5).build();
         final LeafSetEntryNode<Object> fifteen =
                 ImmutableLeafSetEntryNodeBuilder
                         .create()
                         .withNodeIdentifier(
                                         TEST_QNAME, "number"), 5))).withValue(5).build();
         final LeafSetEntryNode<Object> fifteen =
                 ImmutableLeafSetEntryNodeBuilder
                         .create()
                         .withNodeIdentifier(

-                                (new YangInstanceIdentifier.NodeWithValue(QName.create(
+                                (new NodeWithValue<>(QName.create(

                                         TEST_QNAME, "number"), 15))).withValue(15).build();
         final LeafSetNode<Object> numbers =
                 ImmutableLeafSetNodeBuilder
                         .create()
                         .withNodeIdentifier(
                                         TEST_QNAME, "number"), 15))).withValue(15).build();
         final LeafSetNode<Object> numbers =
                 ImmutableLeafSetNodeBuilder
                         .create()
                         .withNodeIdentifier(

-                                new YangInstanceIdentifier.NodeIdentifier(QName.create(
+                                new NodeIdentifier(QName.create(

                                         TEST_QNAME, "number"))).withChild(five).withChild(fifteen)
                         .build();
 
                                         TEST_QNAME, "number"))).withChild(five).withChild(fifteen)
                         .build();
 


@@ -320,11 +324,10 @@ public class TestModel {
         MapEntryNode augMapEntry = createAugmentedListEntry(1, "First Test");
 
         // Create a bits leaf
         MapEntryNode augMapEntry = createAugmentedListEntry(1, "First Test");
 
         // Create a bits leaf

-        NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Object, LeafNode<Object>>
-                myBits = Builders.leafBuilder().withNodeIdentifier(
-                new YangInstanceIdentifier.NodeIdentifier(
-                        QName.create(TEST_QNAME, "my-bits"))).withValue(
-                ImmutableSet.of("foo", "bar"));
+        NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>>
+                myBits = Builders.leafBuilder()
+                .withNodeIdentifier(new NodeIdentifier(QName.create(TEST_QNAME, "my-bits")))
+                .withValue(ImmutableSet.of("foo", "bar"));

 
         // Create unkeyed list entry
         UnkeyedListEntryNode unkeyedListEntry =
 
         // Create unkeyed list entry
         UnkeyedListEntryNode unkeyedListEntry =


@@ -333,12 +336,12 @@ public class TestModel {
 
         // Create YangInstanceIdentifier with all path arg types.
         YangInstanceIdentifier instanceID = YangInstanceIdentifier.create(
 
         // Create YangInstanceIdentifier with all path arg types.
         YangInstanceIdentifier instanceID = YangInstanceIdentifier.create(

-                new YangInstanceIdentifier.NodeIdentifier(QName.create(TEST_QNAME, "qname")),
-                new YangInstanceIdentifier.NodeIdentifierWithPredicates(QName.create(TEST_QNAME, "list-entry"),
+                new NodeIdentifier(QName.create(TEST_QNAME, "qname")),
+                new NodeIdentifierWithPredicates(QName.create(TEST_QNAME, "list-entry"),

                         QName.create(TEST_QNAME, "key"), 10),
                         QName.create(TEST_QNAME, "key"), 10),

-                new YangInstanceIdentifier.AugmentationIdentifier(ImmutableSet.of(
+                new AugmentationIdentifier(ImmutableSet.of(

                         QName.create(TEST_QNAME, "aug1"), QName.create(TEST_QNAME, "aug2"))),
                         QName.create(TEST_QNAME, "aug1"), QName.create(TEST_QNAME, "aug2"))),

-                new YangInstanceIdentifier.NodeWithValue(QName.create(TEST_QNAME, "leaf-list-entry"), "foo"));
+                new NodeWithValue<>(QName.create(TEST_QNAME, "leaf-list-entry"), "foo"));

 
         Map<QName, Object> keyValues = new HashMap<>();
         keyValues.put(CHILDREN_QNAME, FIRST_CHILD_NAME);
 
         Map<QName, Object> keyValues = new HashMap<>();
         keyValues.put(CHILDREN_QNAME, FIRST_CHILD_NAME);

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/schema/provider/impl/RemoteSchemaProviderTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/schema/provider/impl/RemoteSchemaProviderTest.java
index 2c48b2c6c6da4f102dd66f93d437ac8594152c22..34296001409dbc13f491abc7a507f39f91db87cc 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/schema/provider/impl/RemoteSchemaProviderTest.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/schema/provider/impl/RemoteSchemaProviderTest.java
@@ -60,7 +60,7 @@ public class RemoteSchemaProviderTest {
         Mockito.when(mockedRemoteSchemaRepository.getYangTextSchemaSource(ID)).thenReturn(
                 Futures.<YangTextSchemaSourceSerializationProxy>failed(new SchemaSourceException("Source not provided")));
 
         Mockito.when(mockedRemoteSchemaRepository.getYangTextSchemaSource(ID)).thenReturn(
                 Futures.<YangTextSchemaSourceSerializationProxy>failed(new SchemaSourceException("Source not provided")));
 

-        CheckedFuture sourceFuture = remoteSchemaProvider.getSource(ID);
+        CheckedFuture<?, ?> sourceFuture = remoteSchemaProvider.getSource(ID);

         assertTrue(sourceFuture.isDone());
         sourceFuture.checkedGet();
     }
         assertTrue(sourceFuture.isDone());
         sourceFuture.checkedGet();
     }