X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-clustering-commons%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2Fnode%2Futils%2Fstream%2FNormalizedNodeInputStreamReader.java;h=428a578e808950a0d445708be7b74579529f65ed;hp=3b912e6cb9064e2bd7ff50a5bbaa72e629eea131;hb=315a23ea8d215ac5b29fea613f31fd35f6a6899b;hpb=877dc93c690dba7b2a834e0cf585d45250eb9aa2

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 3b912e6cb9..428a578e80 100755
--- 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
@@ -10,23 +10,24 @@ package org.opendaylight.controller.cluster.datastore.node.utils.stream;
 
 import com.google.common.base.Preconditions;
 import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableList.Builder;
 import java.io.DataInput;
 import java.io.IOException;
 import java.io.StringReader;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.transform.dom.DOMSource;
 import org.opendaylight.controller.cluster.datastore.node.utils.QNameFactory;
+import org.opendaylight.yangtools.util.ImmutableOffsetMapTemplate;
+import org.opendaylight.yangtools.yang.common.Empty;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
@@ -136,8 +137,7 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput
                 return leafSetEntryBuilder().withNodeIdentifier(leafIdentifier).withValue(value).build();
 
             case NodeTypes.MAP_ENTRY_NODE :
-                NodeIdentifierWithPredicates entryIdentifier = new NodeIdentifierWithPredicates(
-                        readQName(), readKeyValueMap());
+                NodeIdentifierWithPredicates entryIdentifier = readNormalizedNodeWithPredicates();
 
                 LOG.trace("Reading map entry node {} ", entryIdentifier);
 
@@ -213,12 +213,10 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput
 
             case NodeTypes.ORDERED_LEAF_SET:
                 LOG.trace("Read ordered leaf set node {}", identifier);
-                ListNodeBuilder<Object, LeafSetEntryNode<Object>> orderedLeafSetBuilder =
-                        Builders.orderedLeafSetBuilder().withNodeIdentifier(identifier);
-                orderedLeafSetBuilder = addLeafSetChildren(identifier.getNodeType(), orderedLeafSetBuilder);
-                return orderedLeafSetBuilder.build();
+                return addLeafSetChildren(identifier.getNodeType(),
+                        Builders.orderedLeafSetBuilder().withNodeIdentifier(identifier)).build();
 
-            default :
+            default:
                 return null;
         }
     }
@@ -278,15 +276,26 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput
         return children;
     }
 
-    private Map<QName, Object> readKeyValueMap() throws IOException {
-        int count = input.readInt();
-        Map<QName, Object> keyValueMap = new HashMap<>(count);
+    private NodeIdentifierWithPredicates readNormalizedNodeWithPredicates() throws IOException {
+        final QName qname = readQName();
+        final int count = input.readInt();
+        switch (count) {
+            case 0:
+                return new NodeIdentifierWithPredicates(qname);
+            case 1:
+                return new NodeIdentifierWithPredicates(qname, readQName(), readObject());
+            default:
+                // ImmutableList is used by ImmutableOffsetMapTemplate for lookups, hence we use that.
+                final Builder<QName> keys = ImmutableList.builderWithExpectedSize(count);
+                final Object[] values = new Object[count];
+                for (int i = 0; i < count; i++) {
+                    keys.add(readQName());
+                    values[i] = readObject();
+                }
 
-        for (int i = 0; i < count; i++) {
-            keyValueMap.put(readQName(), readObject());
+                return new NodeIdentifierWithPredicates(qname, ImmutableOffsetMapTemplate.ordered(keys.build())
+                    .instantiateWithValues(values));
         }
-
-        return keyValueMap;
     }
 
     private Object readObject() throws IOException {
@@ -333,6 +342,15 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput
             case ValueTypes.YANG_IDENTIFIER_TYPE :
                 return readYangInstanceIdentifierInternal();
 
+            case ValueTypes.EMPTY_TYPE:
+            // Leaf nodes no longer allow null values and thus we no longer emit null values. Previously, the "empty"
+            // yang type was represented as null so we translate an incoming null value to Empty. It was possible for
+            // a BI user to set a string leaf to null and we're rolling the dice here but the chances for that are
+            // very low. We'd have to know the yang type but, even if we did, we can't let a null value pass upstream
+            // so we'd have to drop the leaf which might cause other issues.
+            case ValueTypes.NULL_TYPE:
+                return Empty.getInstance();
+
             default :
                 return null;
         }
@@ -350,12 +368,12 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput
 
         final boolean absolute = input.readBoolean();
         final int size = input.readInt();
-        final Collection<QName> qnames = new ArrayList<>(size);
+
+        final Builder<QName> qnames = ImmutableList.builderWithExpectedSize(size);
         for (int i = 0; i < size; ++i) {
             qnames.add(readQName());
         }
-
-        return SchemaPath.create(qnames, absolute);
+        return SchemaPath.create(qnames.build(), absolute);
     }
 
     @Override
@@ -366,13 +384,11 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput
 
     private YangInstanceIdentifier readYangInstanceIdentifierInternal() throws IOException {
         int size = input.readInt();
-
-        List<PathArgument> pathArguments = new ArrayList<>(size);
-
+        final Builder<PathArgument> pathArguments = ImmutableList.builderWithExpectedSize(size);
         for (int i = 0; i < size; i++) {
             pathArguments.add(readPathArgument());
         }
-        return YangInstanceIdentifier.create(pathArguments);
+        return YangInstanceIdentifier.create(pathArguments.build());
     }
 
     private Set<String> readObjSet() throws IOException {
@@ -398,7 +414,7 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput
                 return new NodeIdentifier(readQName());
 
             case PathArgumentTypes.NODE_IDENTIFIER_WITH_PREDICATES :
-                return new NodeIdentifierWithPredicates(readQName(), readKeyValueMap());
+                return readNormalizedNodeWithPredicates();
 
             case PathArgumentTypes.NODE_IDENTIFIER_WITH_VALUE :
                 return new NodeWithValue<>(readQName(), readObject());