Improve NormalizedNodeInputStreamReader

[controller.git] / opendaylight / md-sal / sal-clustering-commons / src / main / java / org / opendaylight / controller / cluster / datastore / node / utils / stream / NormalizedNodeInputStreamReader.java

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 211f8b521f7bb267815085cdd0a4ecba2d7085bf..428a578e808950a0d445708be7b74579529f65ed 100755 (executable)
--- 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,23 @@ 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;
@@ -137,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);
 
@@ -277,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 {
@@ -358,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
@@ -374,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 {
@@ -406,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());