Optimized version of NormalizedNode Serialization 68/10268/9
authorMoiz Raja <moraja@cisco.com>
Tue, 26 Aug 2014 02:04:30 +0000 (19:04 -0700)
committertpantelis <tpanteli@brocade.com>
Mon, 25 Aug 2014 14:53:29 +0000 (10:53 -0400)
This commit contains the following,
- Conversion of NormalizedNode to Protocol Buffer using simple tree traversal
- Encoding of QNames and other values to small sized codes to reduce the size of the protobuf message
- Also we now do not use SchemaContext for decoding a NormalizedNode

In addition to these changes I have snuck in an unrelated change to the pom files
to get the appropriate jacoco settings in it.

Change-Id: I6ab48c9f53cf76d6d0c865cf6e5522ff27a30e3f
Signed-off-by: Moiz Raja <moraja@cisco.com>
22 files changed:
opendaylight/md-sal/sal-clustering-commons/pom.xml
opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/NormalizedNodeToNodeCodec.java
opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeDeSerializationContext.java [new file with mode: 0644]
opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeSerializationContext.java [new file with mode: 0644]
opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeSerializer.java [new file with mode: 0644]
opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeType.java [new file with mode: 0644]
opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/PathArgumentSerializer.java [new file with mode: 0644]
opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/PathArgumentType.java [new file with mode: 0644]
opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/ValueSerializer.java [new file with mode: 0644]
opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/ValueType.java [new file with mode: 0644]
opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/protobuff/messages/common/NormalizedNodeMessages.java
opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/protobuff/messages/transaction/ShardTransactionMessages.java
opendaylight/md-sal/sal-clustering-commons/src/main/resources/Common.proto
opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/NormalizedNodeToNodeCodecTest.java
opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeSerializerTest.java [new file with mode: 0644]
opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/PathArgumentSerializerTest.java [new file with mode: 0644]
opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/ValueSerializerTest.java [new file with mode: 0644]
opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/util/TestModel.java
opendaylight/md-sal/sal-clustering-commons/src/test/resources/odl-datastore-test.yang
opendaylight/md-sal/sal-distributed-datastore/pom.xml
opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTransactionFailureTest.java
opendaylight/md-sal/sal-remoterpc-connector/pom.xml

index 4419d19..c533cb1 100644 (file)
       <artifactId>junit</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-all</artifactId>
+      <scope>test</scope>
+    </dependency>
     <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-simple</artifactId>
           <version>3.0.1</version>
       </dependency>
   </dependencies>
+  <build>
+      <plugins>
+          <plugin>
+              <groupId>org.jacoco</groupId>
+              <artifactId>jacoco-maven-plugin</artifactId>
+              <configuration>
+                  <includes>
+                      <include>org.opendaylight.controller.*</include>
+                  </includes>
+                  <excludes>
+                      <exclude>org.opendaylight.controller.protobuff.*</exclude>
+                  </excludes>
+                  <check>false</check>
+              </configuration>
+              <executions>
+                  <execution>
+                      <id>pre-test</id>
+                      <goals>
+                          <goal>prepare-agent</goal>
+                      </goals>
+                  </execution>
+                  <execution>
+                      <id>post-test</id>
+                      <goals>
+                          <goal>report</goal>
+                      </goals>
+                      <phase>test</phase>
+                  </execution>
+              </executions>
+          </plugin>
+      </plugins>
+  </build>
 
 </project>
index d1ae264..4e76e37 100644 (file)
@@ -10,9 +10,9 @@
 
 package org.opendaylight.controller.cluster.datastore.node;
 
-import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
 import org.opendaylight.controller.cluster.datastore.node.utils.PathUtils;
-import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeSerializer;
+import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
@@ -29,45 +29,27 @@ public class NormalizedNodeToNodeCodec {
     }
 
     public NormalizedNodeMessages.Container encode(YangInstanceIdentifier id, NormalizedNode node){
+
+        NormalizedNodeMessages.Container.Builder builder = NormalizedNodeMessages.Container.newBuilder();
         String parentPath = "";
 
         if(id != null){
             parentPath = PathUtils.getParentPath(PathUtils.toString(id));
         }
 
+        builder.setParentPath(parentPath);
+        if(node != null) {
+            builder.setNormalizedNode(NormalizedNodeSerializer.serialize(node));
+        }
 
-        NormalizedNodeToProtocolBufferNode encoder = new NormalizedNodeToProtocolBufferNode();
-        encoder.encode(parentPath, node);
-
-        return encoder.getContainer();
-
-
+        return builder.build();
     }
 
     public NormalizedNode<?,?> decode(YangInstanceIdentifier id, NormalizedNodeMessages.Node node){
-            NodeToNormalizedNodeBuilder currentOp = NodeToNormalizedNodeBuilder.from(ctx);
-
-            for(YangInstanceIdentifier.PathArgument pathArgument : id.getPathArguments()){
-                currentOp = currentOp.getChild(pathArgument);
-            }
-
-            QName nodeType = null;
-
-            if(id.getPath().size() < 1){
-                nodeType = null;
-            } else {
-                final YangInstanceIdentifier.PathArgument pathArgument = id.getPath().get(id.getPath().size() - 1);
-                if(pathArgument instanceof YangInstanceIdentifier.AugmentationIdentifier){
-                    nodeType = null;
-                } else {
-                    nodeType = pathArgument.getNodeType();
-                }
-            }
-            if((node != null)&& (!node.getType().isEmpty())){
-               return currentOp.normalize(nodeType, node);
-            } else{
-              return null;
-            }
+        if(node.getIntType() < 0 || node.getSerializedSize() == 0){
+            return null;
+        }
+        return NormalizedNodeSerializer.deSerialize(node);
     }
 
 
diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeDeSerializationContext.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeDeSerializationContext.java
new file mode 100644 (file)
index 0000000..0ed1317
--- /dev/null
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
+
+/**
+ * NormalizedNodeDeSerializationContext provides methods which help in decoding
+ * certain components of a NormalizedNode properly
+ */
+
+public interface NormalizedNodeDeSerializationContext {
+    String getNamespace(int namespace);
+    String getRevision(int revision);
+    String getLocalName(int localName);
+}
diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeSerializationContext.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeSerializationContext.java
new file mode 100644 (file)
index 0000000..660bc28
--- /dev/null
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
+
+import java.net.URI;
+import java.util.Date;
+
+/**
+ * NormalizedNodeSerializationContext provides methods which help in encoding
+ * certain components of a NormalizedNode properly
+ */
+public interface NormalizedNodeSerializationContext {
+    int addNamespace(URI namespace);
+    int addRevision(Date revision);
+    int addLocalName(String localName);
+}
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
new file mode 100644 (file)
index 0000000..3e1bd35
--- /dev/null
@@ -0,0 +1,551 @@
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
+
+import com.google.common.base.Preconditions;
+import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
+import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
+import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
+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.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeType.ANY_XML_NODE_TYPE;
+import static org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeType.AUGMENTATION_NODE_TYPE;
+import static org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeType.CHOICE_NODE_TYPE;
+import static org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeType.CONTAINER_NODE_TYPE;
+import static org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeType.LEAF_NODE_TYPE;
+import static org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeType.LEAF_SET_ENTRY_NODE_TYPE;
+import static org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeType.LEAF_SET_NODE_TYPE;
+import static org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeType.MAP_ENTRY_NODE_TYPE;
+import static org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeType.MAP_NODE_TYPE;
+import static org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeType.ORDERED_LEAF_SET_NODE_TYPE;
+import static org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeType.ORDERED_MAP_NODE_TYPE;
+import static org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeType.UNKEYED_LIST_ENTRY_NODE_TYPE;
+import static org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeType.UNKEYED_LIST_NODE_TYPE;
+import static org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeType.getSerializableNodeType;
+
+/**
+ * NormalizedNodeSerializer can be used to convert a Normalized node to and and
+ * from a protocol buffer message.
+ *
+ *
+ */
+public class NormalizedNodeSerializer {
+
+    /**
+     * Serialize a NormalizedNode into a protocol buffer message
+     * <p>
+     * The significant things to be aware of the Serialization process are
+     * <ul>
+     *     <li>Repeated strings like namespaces, revisions and localNames are
+     *     compressed to codes and stored in the top level of the normalized
+     *     node protocol buffer message
+     *     </li>
+     *     <li>All value types are encoded for each leaf value. This is so that
+     *     the deSerialization process does not need to use the schema context to
+     *     figure out how to decode values
+     *     </li>
+     * </ul>
+     *
+     * One question which may arise is why not use something like gzip to
+     * compress the protocol buffer message instead of rolling our own
+     * encoding scheme. This has to be explored further as it is a more
+     * general solution.
+     *
+     * @param node
+     * @return
+     */
+    public static NormalizedNodeMessages.Node serialize(NormalizedNode node){
+        Preconditions.checkNotNull(node, "node should not be null");
+        return new Serializer(node).serialize();
+    }
+
+
+    /**
+     * DeSerialize a protocol buffer message back into a NormalizedNode
+     *
+     * @param node
+     * @return
+     */
+    public static NormalizedNode deSerialize(NormalizedNodeMessages.Node node){
+        return new DeSerializer(node).deSerialize();
+    }
+
+    /**
+     * DeSerialize a PathArgument which is in the protocol buffer format into
+     * a yang PathArgument. The protocol buffer path argument is specially
+     * encoded and can only be interpreted in the context of a top level
+     * serialized NormalizedNode protocol buffer message. The reason for this
+     * is that during the NormalizedNode serialization process certain repeated
+     * strings are encoded into a "codes" list and the actual strings are
+     * replaced by an integer which is an index into that list.
+     *
+     * @param node
+     * @param pathArgument
+     * @return
+     */
+    public static YangInstanceIdentifier.PathArgument deSerialize(NormalizedNodeMessages.Node node, NormalizedNodeMessages.PathArgument pathArgument){
+        Preconditions.checkNotNull(node, "node should not be null");
+        Preconditions.checkNotNull(pathArgument, "pathArgument should not be null");
+        return new DeSerializer(node).deSerialize(pathArgument);
+    }
+
+    private static class Serializer implements NormalizedNodeSerializationContext {
+
+        private final NormalizedNode node;
+
+        private final Map<Object, Integer> codeMap = new HashMap<>();
+        private final List<String> codes = new ArrayList<>();
+
+        private Serializer(NormalizedNode node) {
+            this.node = node;
+        }
+
+        private NormalizedNodeMessages.Node serialize() {
+            return this.serialize(node).addAllCode(codes).build();
+        }
+
+        private NormalizedNodeMessages.Node.Builder serialize(
+            NormalizedNode node) {
+            NormalizedNodeMessages.Node.Builder builder =
+                NormalizedNodeMessages.Node.newBuilder();
+
+            builder.setPathArgument(PathArgumentSerializer.serialize(this, node.getIdentifier()));
+            Integer nodeType = getSerializableNodeType(node).ordinal();
+            builder.setIntType(nodeType);
+            Object value = node.getValue();
+
+            // We need to do a specific check of the type of the node here
+            // because if we looked at the value type alone we will not be
+            // able to distinguish if the value was supposed to be added
+            // as a child or whether the value should be added as a value of the
+            // node.
+            // One use case where this check is necessary when you have a node
+            // with a bits value. In that case the value of the node is a Set
+            // which is also a Collection. Without the following check being
+            // done first the code would flow into the Collection if condition
+            // and the Set would be added as child nodes
+            if(nodeType == NormalizedNodeType.LEAF_NODE_TYPE.ordinal() ||
+               nodeType == NormalizedNodeType.LEAF_SET_ENTRY_NODE_TYPE.ordinal()){
+
+                ValueSerializer.serialize(builder, this, value);
+
+            } else if (value instanceof Iterable) {
+                Iterable iterable = (Iterable) value;
+
+                for (Object o : iterable) {
+                    if (o instanceof NormalizedNode) {
+                        builder.addChild(serialize((NormalizedNode) o));
+                    }
+                }
+
+            } else if (value instanceof NormalizedNode) {
+
+                builder.addChild(serialize((NormalizedNode) value));
+
+            } else {
+
+                ValueSerializer.serialize(builder, this, value);
+            }
+
+            return builder;
+        }
+
+
+        @Override public int addNamespace(URI namespace) {
+            int namespaceInt = getCode(namespace);
+
+            if(namespaceInt == -1) {
+                namespaceInt = addCode(namespace, namespace.toString());
+            }
+            return namespaceInt;
+        }
+
+        @Override public int addRevision(Date revision) {
+            if(revision == null){
+                return -1;
+            }
+
+            int revisionInt = getCode(revision);
+            if(revisionInt == -1) {
+                String formattedRevision =
+                    SimpleDateFormatUtil.getRevisionFormat().format(revision);
+                revisionInt = addCode(revision, formattedRevision);
+            }
+            return revisionInt;
+        }
+
+        @Override public int addLocalName(String localName) {
+            int localNameInt = getCode(localName);
+            if(localNameInt == -1) {
+                localNameInt = addCode(localName, localName.toString());
+            }
+            return localNameInt;
+
+        }
+
+        public int addCode(Object code, String codeStr){
+            int count = codes.size();
+            codes.add(codeStr);
+            codeMap.put(code, Integer.valueOf(count));
+            return count;
+        }
+
+        public int getCode(Object code){
+            if(codeMap.containsKey(code)){
+                return codeMap.get(code);
+            }
+            return -1;
+        }
+    }
+
+    private static class DeSerializer implements NormalizedNodeDeSerializationContext {
+        private static Map<NormalizedNodeType, DeSerializationFunction>
+            deSerializationFunctions = new HashMap<>();
+
+        static {
+            deSerializationFunctions.put(CONTAINER_NODE_TYPE,
+                new DeSerializationFunction() {
+                    @Override public NormalizedNode apply(
+                        DeSerializer deSerializer,
+                        NormalizedNodeMessages.Node node) {
+                        DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode>
+                            builder = Builders.containerBuilder();
+
+                        builder
+                            .withNodeIdentifier(deSerializer.toNodeIdentifier(
+                                node.getPathArgument()));
+
+                        return deSerializer.buildDataContainer(builder, node);
+
+                    }
+
+                });
+
+            deSerializationFunctions.put(LEAF_NODE_TYPE,
+                new DeSerializationFunction() {
+                    @Override public NormalizedNode apply(
+                        DeSerializer deSerializer,
+                        NormalizedNodeMessages.Node node) {
+                        NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Object, LeafNode<Object>>
+                            builder = Builders.leafBuilder();
+
+                        builder
+                            .withNodeIdentifier(deSerializer.toNodeIdentifier(
+                                node.getPathArgument()));
+
+                        return deSerializer.buildNormalizedNode(builder, node);
+
+                    }
+                });
+
+            deSerializationFunctions.put(MAP_NODE_TYPE,
+                new DeSerializationFunction() {
+                    @Override public NormalizedNode apply(
+                        DeSerializer deSerializer,
+                        NormalizedNodeMessages.Node node) {
+                        CollectionNodeBuilder<MapEntryNode, MapNode>
+                            builder = Builders.mapBuilder();
+
+                        return deSerializer.buildCollectionNode(builder, node);
+                    }
+                });
+
+            deSerializationFunctions.put(MAP_ENTRY_NODE_TYPE,
+                new DeSerializationFunction() {
+                    @Override public NormalizedNode apply(
+                        DeSerializer deSerializer,
+                        NormalizedNodeMessages.Node node) {
+                        DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode>
+                            builder = Builders.mapEntryBuilder();
+
+                        builder.withNodeIdentifier(deSerializer.toNodeIdentifierWithPredicates(
+                            node.getPathArgument()));
+
+                        return deSerializer.buildDataContainer(builder, node);
+                    }
+                });
+
+            deSerializationFunctions.put(AUGMENTATION_NODE_TYPE,
+                new DeSerializationFunction() {
+                    @Override public NormalizedNode apply(
+                        DeSerializer deSerializer,
+                        NormalizedNodeMessages.Node node) {
+                        DataContainerNodeBuilder<YangInstanceIdentifier.AugmentationIdentifier, AugmentationNode>
+                            builder = Builders.augmentationBuilder();
+
+                        builder.withNodeIdentifier(
+                            deSerializer.toAugmentationIdentifier(
+                                node.getPathArgument()));
+
+                        return deSerializer.buildDataContainer(builder, node);
+                    }
+                });
+
+            deSerializationFunctions.put(LEAF_SET_NODE_TYPE,
+                new DeSerializationFunction() {
+                    @Override public NormalizedNode apply(
+                        DeSerializer deSerializer,
+                        NormalizedNodeMessages.Node node) {
+                        ListNodeBuilder<Object, LeafSetEntryNode<Object>>
+                            builder = Builders.leafSetBuilder();
+
+                        return deSerializer.buildListNode(builder, node);
+                    }
+                });
+
+            deSerializationFunctions.put(LEAF_SET_ENTRY_NODE_TYPE,
+                new DeSerializationFunction() {
+                    @Override public NormalizedNode apply(
+                        DeSerializer deSerializer,
+                        NormalizedNodeMessages.Node node) {
+                        NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeWithValue, Object, LeafSetEntryNode<Object>>
+                            builder = Builders.leafSetEntryBuilder();
+
+                        builder.withNodeIdentifier(deSerializer.toNodeWithValue(
+                            node.getPathArgument()));
+
+                        return deSerializer.buildNormalizedNode(builder, node);
+                    }
+                });
+
+            deSerializationFunctions.put(CHOICE_NODE_TYPE,
+                new DeSerializationFunction() {
+                    @Override public NormalizedNode apply(
+                        DeSerializer deSerializer,
+                        NormalizedNodeMessages.Node node) {
+                        DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ChoiceNode>
+                            builder =
+                            Builders.choiceBuilder();
+
+                        builder
+                            .withNodeIdentifier(deSerializer.toNodeIdentifier(
+                                node.getPathArgument()));
+
+                        return deSerializer.buildDataContainer(builder, node);
+                    }
+                });
+
+            deSerializationFunctions.put(ORDERED_LEAF_SET_NODE_TYPE,
+                new DeSerializationFunction() {
+                    @Override public NormalizedNode apply(
+                        DeSerializer deSerializer,
+                        NormalizedNodeMessages.Node node) {
+                        ListNodeBuilder<Object, LeafSetEntryNode<Object>>
+                            builder =
+                            Builders.orderedLeafSetBuilder();
+
+                        return deSerializer.buildListNode(builder, node);
+
+
+                    }
+                });
+
+            deSerializationFunctions.put(ORDERED_MAP_NODE_TYPE,
+                new DeSerializationFunction() {
+                    @Override public NormalizedNode apply(
+                        DeSerializer deSerializer,
+                        NormalizedNodeMessages.Node node) {
+                        CollectionNodeBuilder<MapEntryNode, OrderedMapNode>
+                            builder =
+                            Builders.orderedMapBuilder();
+
+                        return deSerializer.buildCollectionNode(builder, node);
+                    }
+                });
+
+            deSerializationFunctions.put(UNKEYED_LIST_NODE_TYPE,
+                new DeSerializationFunction() {
+                    @Override public NormalizedNode apply(
+                        DeSerializer deSerializer,
+                        NormalizedNodeMessages.Node node) {
+                        CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode>
+                            builder =
+                            Builders.unkeyedListBuilder();
+
+                        return deSerializer.buildCollectionNode(builder, node);
+                    }
+                });
+
+            deSerializationFunctions.put(UNKEYED_LIST_ENTRY_NODE_TYPE,
+                new DeSerializationFunction() {
+                    @Override public NormalizedNode apply(
+                        DeSerializer deSerializer,
+                        NormalizedNodeMessages.Node node) {
+                        DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode>
+                            builder =
+                            Builders.unkeyedListEntryBuilder();
+
+                        builder
+                            .withNodeIdentifier(deSerializer.toNodeIdentifier(
+                                node.getPathArgument()));
+
+                        return deSerializer.buildDataContainer(builder, node);
+                    }
+                });
+
+            deSerializationFunctions.put(ANY_XML_NODE_TYPE,
+                new DeSerializationFunction() {
+
+                    @Override public NormalizedNode apply(
+                        DeSerializer deSerializer,
+                        NormalizedNodeMessages.Node node) {
+                        NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode>
+                            builder =
+                            Builders.anyXmlBuilder();
+
+                        builder
+                            .withNodeIdentifier(deSerializer.toNodeIdentifier(
+                                node.getPathArgument()));
+
+                        return deSerializer.buildNormalizedNode(builder, node);
+                    }
+                });
+
+        }
+
+        private final NormalizedNodeMessages.Node node;
+
+        public DeSerializer(NormalizedNodeMessages.Node node){
+            this.node = node;
+        }
+
+        public NormalizedNode deSerialize(){
+            return deSerialize(node);
+        }
+
+        private NormalizedNode deSerialize(NormalizedNodeMessages.Node node){
+            Preconditions.checkNotNull(node, "node should not be null");
+            DeSerializationFunction deSerializationFunction =
+                Preconditions.checkNotNull(deSerializationFunctions.get(NormalizedNodeType.values()[node.getIntType()]), "Unknown type " + node);
+
+            return deSerializationFunction.apply(this, node);
+        }
+
+
+        private NormalizedNode buildCollectionNode(
+            CollectionNodeBuilder builder,
+            NormalizedNodeMessages.Node node) {
+
+            builder.withNodeIdentifier(toNodeIdentifier(node.getPathArgument()));
+
+            for(NormalizedNodeMessages.Node child : node.getChildList()){
+                builder.withChild(deSerialize(child));
+            }
+
+            return builder.build();
+        }
+
+
+        private NormalizedNode buildListNode(
+            ListNodeBuilder<Object, LeafSetEntryNode<Object>> builder,
+            NormalizedNodeMessages.Node node) {
+            builder.withNodeIdentifier(toNodeIdentifier(node.getPathArgument()));
+
+            for(NormalizedNodeMessages.Node child : node.getChildList()){
+                builder.withChild((LeafSetEntryNode<Object>) deSerialize(child));
+            }
+
+            return builder.build();
+        }
+
+        private NormalizedNode buildDataContainer(DataContainerNodeBuilder builder, NormalizedNodeMessages.Node node){
+
+            for(NormalizedNodeMessages.Node child : node.getChildList()){
+                builder.withChild((DataContainerChild<?, ?>) deSerialize(child));
+            }
+
+            //TODO : Also handle attributes
+
+            return builder.build();
+        }
+
+        private NormalizedNode buildNormalizedNode(NormalizedNodeAttrBuilder builder, NormalizedNodeMessages.Node node){
+
+            builder.withValue(ValueSerializer.deSerialize(this, node));
+
+            //TODO : Also handle attributes
+
+            return builder.build();
+
+        }
+
+
+        private YangInstanceIdentifier.NodeIdentifierWithPredicates toNodeIdentifierWithPredicates(
+            NormalizedNodeMessages.PathArgument path) {
+            return (YangInstanceIdentifier.NodeIdentifierWithPredicates) PathArgumentSerializer.deSerialize(this, path);
+        }
+
+        private YangInstanceIdentifier.AugmentationIdentifier toAugmentationIdentifier(
+            NormalizedNodeMessages.PathArgument path) {
+            return (YangInstanceIdentifier.AugmentationIdentifier) PathArgumentSerializer.deSerialize(this, path);
+        }
+
+        private YangInstanceIdentifier.NodeWithValue toNodeWithValue(
+            NormalizedNodeMessages.PathArgument path) {
+            return (YangInstanceIdentifier.NodeWithValue) PathArgumentSerializer.deSerialize(
+                this, path);
+        }
+
+        private YangInstanceIdentifier.NodeIdentifier toNodeIdentifier(NormalizedNodeMessages.PathArgument path){
+            return (YangInstanceIdentifier.NodeIdentifier) PathArgumentSerializer.deSerialize(
+                this, path);
+        }
+
+        @Override public String getNamespace(int namespace) {
+            return node.getCode(namespace);
+        }
+
+        @Override public String getRevision(int revision) {
+            return node.getCode(revision);
+        }
+
+        @Override public String getLocalName(int localName) {
+            return node.getCode(localName);
+        }
+
+        public YangInstanceIdentifier.PathArgument deSerialize(
+            NormalizedNodeMessages.PathArgument pathArgument) {
+            return PathArgumentSerializer.deSerialize(this, pathArgument);
+        }
+
+        private static interface DeSerializationFunction {
+            NormalizedNode apply(DeSerializer deserializer, NormalizedNodeMessages.Node node);
+        }
+    }
+
+
+
+
+}
diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeType.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeType.java
new file mode 100644 (file)
index 0000000..eebd580
--- /dev/null
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
+
+import com.google.common.base.Preconditions;
+import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
+import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
+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.LeafSetEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.OrderedLeafSetNode;
+import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
+
+public enum NormalizedNodeType {
+    CONTAINER_NODE_TYPE,
+    LEAF_NODE_TYPE,
+    MAP_NODE_TYPE,
+    MAP_ENTRY_NODE_TYPE,
+    AUGMENTATION_NODE_TYPE,
+    LEAF_SET_NODE_TYPE,
+    LEAF_SET_ENTRY_NODE_TYPE,
+    CHOICE_NODE_TYPE,
+    ORDERED_LEAF_SET_NODE_TYPE,
+    ORDERED_MAP_NODE_TYPE,
+    UNKEYED_LIST_NODE_TYPE,
+    UNKEYED_LIST_ENTRY_NODE_TYPE,
+    ANY_XML_NODE_TYPE;
+
+    public static NormalizedNodeType getSerializableNodeType(NormalizedNode node){
+        Preconditions.checkNotNull(node, "node should not be null");
+
+        if(node instanceof ContainerNode){
+            return CONTAINER_NODE_TYPE;
+        } else if(node instanceof LeafNode){
+            return LEAF_NODE_TYPE;
+        } else if(node instanceof MapNode){
+            return MAP_NODE_TYPE;
+        } else if(node instanceof MapEntryNode){
+            return MAP_ENTRY_NODE_TYPE;
+        } else if(node instanceof AugmentationNode){
+            return AUGMENTATION_NODE_TYPE;
+        } else if(node instanceof LeafSetNode){
+            return LEAF_SET_NODE_TYPE;
+        } else if(node instanceof LeafSetEntryNode){
+            return LEAF_SET_ENTRY_NODE_TYPE;
+        } else if(node instanceof ChoiceNode){
+            return CHOICE_NODE_TYPE;
+        } else if(node instanceof OrderedLeafSetNode){
+            return ORDERED_LEAF_SET_NODE_TYPE;
+        } else if(node instanceof OrderedMapNode){
+            return ORDERED_MAP_NODE_TYPE;
+        } else if(node instanceof UnkeyedListNode){
+            return UNKEYED_LIST_NODE_TYPE;
+        } else if(node instanceof UnkeyedListEntryNode){
+            return UNKEYED_LIST_ENTRY_NODE_TYPE;
+        } else if(node instanceof AnyXmlNode){
+            return ANY_XML_NODE_TYPE;
+        }
+        throw new IllegalArgumentException("Node type unknown : " + node.getClass().getSimpleName());
+    }
+
+}
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
new file mode 100644 (file)
index 0000000..d7627c0
--- /dev/null
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
+
+import com.google.common.base.Preconditions;
+import org.opendaylight.controller.cluster.datastore.node.utils.NodeIdentifierFactory;
+import org.opendaylight.controller.cluster.datastore.node.utils.QNameFactory;
+import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.opendaylight.controller.cluster.datastore.node.utils.serialization.PathArgumentType.getSerializablePathArgumentType;
+
+public class PathArgumentSerializer {
+    private static final Map<Class, PathArgumentAttributesGetter> pathArgumentAttributesGetters = new HashMap<>();
+
+    public static NormalizedNodeMessages.PathArgument serialize(NormalizedNodeSerializationContext context, YangInstanceIdentifier.PathArgument pathArgument){
+        Preconditions.checkNotNull(context, "context should not be null");
+        Preconditions.checkNotNull(pathArgument, "pathArgument should not be null");
+
+        QName nodeType = null;
+        if (!(pathArgument instanceof YangInstanceIdentifier.AugmentationIdentifier)) {
+            nodeType = pathArgument.getNodeType();
+        }
+
+        NormalizedNodeMessages.PathArgument.Builder builder =
+            NormalizedNodeMessages.PathArgument.newBuilder();
+
+        NormalizedNodeMessages.PathArgument serializablePathArgument =
+            builder
+                .setIntType(getSerializablePathArgumentType(pathArgument))
+                .setNodeType(encodeQName(context, nodeType))
+                .addAllAttribute(getPathArgumentAttributes(context, pathArgument))
+                .build();
+
+        return serializablePathArgument;
+    }
+
+
+    public static YangInstanceIdentifier.PathArgument deSerialize(NormalizedNodeDeSerializationContext context, NormalizedNodeMessages.PathArgument pathArgument){
+        Preconditions.checkNotNull(context, "context should not be null");
+        Preconditions.checkNotNull(pathArgument, "pathArgument should not be null");
+
+        return parsePathArgument(context, pathArgument);
+    }
+
+
+    private static interface PathArgumentAttributesGetter {
+        Iterable<? extends NormalizedNodeMessages.PathArgumentAttribute> get(NormalizedNodeSerializationContext context,
+            YangInstanceIdentifier.PathArgument pathArgument);
+    }
+
+    static {
+        pathArgumentAttributesGetters.put(YangInstanceIdentifier.NodeWithValue.class, new PathArgumentAttributesGetter() {
+            @Override
+            public Iterable<? extends NormalizedNodeMessages.PathArgumentAttribute> get(
+                NormalizedNodeSerializationContext context,
+                YangInstanceIdentifier.PathArgument pathArgument) {
+                List<NormalizedNodeMessages.PathArgumentAttribute> attributes =
+                    new ArrayList<>();
+
+                YangInstanceIdentifier.NodeWithValue identifier
+                    = (YangInstanceIdentifier.NodeWithValue) pathArgument;
+
+                NormalizedNodeMessages.PathArgumentAttribute attribute =
+                    buildAttribute(context, null, identifier.getValue());
+
+                attributes.add(attribute);
+
+                return attributes;
+
+            }
+        });
+
+        pathArgumentAttributesGetters.put(YangInstanceIdentifier.NodeIdentifierWithPredicates.class, new PathArgumentAttributesGetter() {
+            @Override
+            public Iterable<? extends NormalizedNodeMessages.PathArgumentAttribute> get(
+                NormalizedNodeSerializationContext context,
+                YangInstanceIdentifier.PathArgument pathArgument) {
+
+                List<NormalizedNodeMessages.PathArgumentAttribute> attributes =
+                    new ArrayList<>();
+
+                YangInstanceIdentifier.NodeIdentifierWithPredicates identifier
+                    = (YangInstanceIdentifier.NodeIdentifierWithPredicates) pathArgument;
+
+                for (QName key : identifier.getKeyValues().keySet()) {
+                    Object value = identifier.getKeyValues().get(key);
+                    NormalizedNodeMessages.PathArgumentAttribute attribute =
+                        buildAttribute(context, key, value);
+
+                    attributes.add(attribute);
+
+                }
+
+                return attributes;
+
+            }
+        });
+
+        pathArgumentAttributesGetters.put(YangInstanceIdentifier.AugmentationIdentifier.class, new PathArgumentAttributesGetter() {
+            @Override
+            public Iterable<? extends NormalizedNodeMessages.PathArgumentAttribute> get(
+                NormalizedNodeSerializationContext context,
+                YangInstanceIdentifier.PathArgument pathArgument) {
+
+                List<NormalizedNodeMessages.PathArgumentAttribute> attributes =
+                    new ArrayList<>();
+
+                YangInstanceIdentifier.AugmentationIdentifier identifier
+                    = (YangInstanceIdentifier.AugmentationIdentifier) pathArgument;
+
+                for (QName key : identifier.getPossibleChildNames()) {
+                    Object value = key;
+                    NormalizedNodeMessages.PathArgumentAttribute attribute =
+                        buildAttribute(context, key, value);
+
+                    attributes.add(attribute);
+
+                }
+
+                return attributes;
+
+            }
+        });
+
+
+        pathArgumentAttributesGetters.put(YangInstanceIdentifier.NodeIdentifier.class, new PathArgumentAttributesGetter() {
+            @Override
+            public Iterable<? extends NormalizedNodeMessages.PathArgumentAttribute> get(
+                NormalizedNodeSerializationContext context,
+                YangInstanceIdentifier.PathArgument pathArgument) {
+                return Collections.emptyList();
+            }
+        });
+    }
+
+    private static NormalizedNodeMessages.PathArgumentAttribute buildAttribute(NormalizedNodeSerializationContext context,QName name, Object value){
+        NormalizedNodeMessages.PathArgumentAttribute.Builder builder =
+            NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
+
+        builder.setName(encodeQName(context, name));
+        ValueSerializer.serialize(builder, context, value);
+
+        return builder.build();
+
+    }
+
+    private static NormalizedNodeMessages.QName.Builder encodeQName(NormalizedNodeSerializationContext context, QName qName){
+        if(qName == null){
+            return NormalizedNodeMessages.QName.getDefaultInstance().toBuilder();
+        }
+        NormalizedNodeMessages.QName.Builder qNameBuilder =
+            NormalizedNodeMessages.QName.newBuilder();
+
+        qNameBuilder.setNamespace(context.addNamespace(qName.getNamespace()));
+
+        qNameBuilder.setRevision(context.addRevision(qName.getRevision()));
+
+        qNameBuilder.setLocalName(context.addLocalName(qName.getLocalName()));
+
+        return qNameBuilder;
+    }
+
+    private static Iterable<? extends NormalizedNodeMessages.PathArgumentAttribute> getPathArgumentAttributes(
+            NormalizedNodeSerializationContext context,
+            YangInstanceIdentifier.PathArgument pathArgument) {
+
+        return pathArgumentAttributesGetters.get(pathArgument.getClass()).get(context, pathArgument);
+
+    }
+
+
+    private static String qNameToString(NormalizedNodeDeSerializationContext context,
+        NormalizedNodeMessages.QName qName){
+        // If this serializer is used qName cannot be null (see encodeQName)
+        // adding null check only in case someone tried to deSerialize a protocol buffer node
+        // that was not serialized using the PathArgumentSerializer
+        Preconditions.checkNotNull(qName, "qName should not be null");
+        Preconditions.checkArgument(!"".equals(qName.getLocalName()),
+            "qName.localName cannot be empty qName = " + qName.toString());
+        Preconditions.checkArgument(qName.getNamespace() != -1, "qName.namespace should be valid");
+
+        StringBuilder sb = new StringBuilder();
+        String namespace = context.getNamespace(qName.getNamespace());
+        String revision = "";
+        String localName = context.getLocalName(qName.getLocalName());
+        if(qName.getRevision() != -1){
+            revision = context.getRevision(qName.getRevision());
+            sb.append("(").append(namespace).append("?revision=").append(
+                revision).append(")").append(
+                localName);
+        } else {
+            sb.append("(").append(namespace).append(")").append(
+                localName);
+        }
+
+        return sb.toString();
+
+    }
+
+    /**
+     * Parse a protocol buffer PathArgument and return an MD-SAL PathArgument
+     *
+     * @param pathArgument protocol buffer PathArgument
+     * @return MD-SAL PathArgument
+     */
+    private static YangInstanceIdentifier.PathArgument parsePathArgument(
+        NormalizedNodeDeSerializationContext context,
+        NormalizedNodeMessages.PathArgument pathArgument) {
+
+        Preconditions.checkArgument(pathArgument.getIntType() >= 0
+            && pathArgument.getIntType() < PathArgumentType.values().length,
+            "Illegal PathArgumentType " + pathArgument.getIntType());
+
+        switch(PathArgumentType.values()[pathArgument.getIntType()]){
+            case NODE_IDENTIFIER_WITH_VALUE : {
+
+                YangInstanceIdentifier.NodeWithValue nodeWithValue =
+                    new YangInstanceIdentifier.NodeWithValue(
+                        QNameFactory.create(qNameToString(context, pathArgument.getNodeType())),
+                        parseAttribute(context, pathArgument.getAttribute(0)));
+
+                return nodeWithValue;
+            }
+
+            case NODE_IDENTIFIER_WITH_PREDICATES : {
+
+                YangInstanceIdentifier.NodeIdentifierWithPredicates
+                    nodeIdentifierWithPredicates =
+                    new YangInstanceIdentifier.NodeIdentifierWithPredicates(
+                        QNameFactory.create(qNameToString(context, pathArgument.getNodeType())),
+                        toAttributesMap(context, pathArgument.getAttributeList()));
+
+                return nodeIdentifierWithPredicates;
+            }
+
+            case AUGMENTATION_IDENTIFIER: {
+
+                Set<QName> qNameSet = new HashSet<>();
+
+                for(NormalizedNodeMessages.PathArgumentAttribute attribute : pathArgument.getAttributeList()){
+                    qNameSet.add(QNameFactory.create(qNameToString(context, attribute.getName())));
+                }
+
+                return new YangInstanceIdentifier.AugmentationIdentifier(qNameSet);
+
+            }
+            default: {
+                return NodeIdentifierFactory.getArgument(qNameToString(context,
+                    pathArgument.getNodeType()));
+            }
+
+        }
+    }
+
+    private static Map<QName, Object> toAttributesMap(
+        NormalizedNodeDeSerializationContext context,
+        List<NormalizedNodeMessages.PathArgumentAttribute> attributesList) {
+
+        Map<QName, Object> map = new HashMap<>();
+
+        for(NormalizedNodeMessages.PathArgumentAttribute attribute : attributesList){
+            NormalizedNodeMessages.QName name = attribute.getName();
+            Object value = parseAttribute(context, attribute);
+
+            map.put(QNameFactory.create(qNameToString(context, name)), value);
+        }
+
+        return map;
+    }
+
+    private static Object parseAttribute(NormalizedNodeDeSerializationContext context, NormalizedNodeMessages.PathArgumentAttribute attribute){
+        return ValueSerializer.deSerialize(context, attribute);
+    }
+
+}
diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/PathArgumentType.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/PathArgumentType.java
new file mode 100644 (file)
index 0000000..20009d8
--- /dev/null
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
+
+import com.google.common.base.Preconditions;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+
+public enum PathArgumentType {
+    AUGMENTATION_IDENTIFIER,
+    NODE_IDENTIFIER,
+    NODE_IDENTIFIER_WITH_VALUE,
+    NODE_IDENTIFIER_WITH_PREDICATES;
+
+    public static int getSerializablePathArgumentType(YangInstanceIdentifier.PathArgument pathArgument){
+        Preconditions.checkNotNull(pathArgument, "pathArgument should not be null");
+
+        if(pathArgument instanceof YangInstanceIdentifier.AugmentationIdentifier){
+            return AUGMENTATION_IDENTIFIER.ordinal();
+        } else if(pathArgument instanceof YangInstanceIdentifier.NodeIdentifier){
+            return NODE_IDENTIFIER.ordinal();
+        } else if(pathArgument instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates){
+            return NODE_IDENTIFIER_WITH_PREDICATES.ordinal();
+        } else if(pathArgument instanceof YangInstanceIdentifier.NodeWithValue){
+            return NODE_IDENTIFIER_WITH_VALUE.ordinal();
+        }
+        throw new IllegalArgumentException("Unknown type of PathArgument = " + pathArgument.toString());
+    }
+
+}
diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/ValueSerializer.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/ValueSerializer.java
new file mode 100644 (file)
index 0000000..04c95d6
--- /dev/null
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
+
+import com.google.common.base.Preconditions;
+import org.opendaylight.controller.cluster.datastore.node.utils.QNameFactory;
+import org.opendaylight.controller.cluster.datastore.util.InstanceIdentifierUtils;
+import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.HashSet;
+import java.util.Set;
+
+public class ValueSerializer {
+    public static void serialize(NormalizedNodeMessages.Node.Builder builder,
+        NormalizedNodeSerializationContext context, Object value){
+        builder.setIntValueType(ValueType.getSerializableType(value).ordinal());
+
+        if(value instanceof YangInstanceIdentifier) {
+            builder.setInstanceIdentifierValue(
+                InstanceIdentifierUtils.toSerializable((YangInstanceIdentifier) value));
+        } else if(value instanceof Set) {
+            Set set = (Set) value;
+            if(!set.isEmpty()){
+                for(Object o : set){
+                    if(o instanceof String){
+                        builder.addBitsValue(o.toString());
+                    } else {
+                        throw new IllegalArgumentException("Expected value type to be Bits but was : " +
+                            value.toString());
+                    }
+                }
+            }
+        } else {
+            builder.setValue(value.toString());
+        }
+    }
+
+    public static void serialize(NormalizedNodeMessages.PathArgumentAttribute.Builder builder,
+        NormalizedNodeSerializationContext context, Object value){
+
+        builder.setType(ValueType.getSerializableType(value).ordinal());
+        builder.setValue(value.toString());
+    }
+
+    public static Object deSerialize(
+        NormalizedNodeDeSerializationContext context, NormalizedNodeMessages.Node node) {
+        if(node.getIntValueType() == ValueType.YANG_IDENTIFIER_TYPE.ordinal()){
+            return InstanceIdentifierUtils.fromSerializable(
+                node.getInstanceIdentifierValue());
+        } else if(node.getIntValueType() == ValueType.BITS_TYPE.ordinal()){
+            return new HashSet(node.getBitsValueList());
+        }
+        return deSerializeBasicTypes(node.getIntValueType(), node.getValue());
+    }
+
+    public static Object deSerialize(
+        NormalizedNodeDeSerializationContext context,
+        NormalizedNodeMessages.PathArgumentAttribute attribute) {
+        return deSerializeBasicTypes(attribute.getType(), attribute.getValue());
+    }
+
+
+    private static Object deSerializeBasicTypes(int valueType, String value) {
+        Preconditions.checkArgument(valueType >= 0 && valueType < ValueType.values().length,
+            "Illegal value type " + valueType );
+
+        switch(ValueType.values()[valueType]){
+           case SHORT_TYPE: {
+               return Short.valueOf(value);
+           }
+           case BOOL_TYPE: {
+               return Boolean.valueOf(value);
+           }
+           case BYTE_TYPE: {
+               return Byte.valueOf(value);
+           }
+           case INT_TYPE : {
+                return Integer.valueOf(value);
+           }
+           case LONG_TYPE: {
+               return Long.valueOf(value);
+           }
+           case QNAME_TYPE: {
+               return QNameFactory.create(value);
+           }
+           case BIG_INTEGER_TYPE: {
+               return new BigInteger(value);
+           }
+           case BIG_DECIMAL_TYPE: {
+               return new BigDecimal(value);
+           }
+           default: {
+               return value;
+           }
+        }
+    }
+
+}
diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/ValueType.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/ValueType.java
new file mode 100644 (file)
index 0000000..8724dfe
--- /dev/null
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
+
+import com.google.common.base.Preconditions;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+public enum ValueType {
+    SHORT_TYPE,
+    BYTE_TYPE,
+    INT_TYPE,
+    LONG_TYPE,
+    BOOL_TYPE,
+    QNAME_TYPE,
+    BITS_TYPE,
+    YANG_IDENTIFIER_TYPE,
+    STRING_TYPE,
+    BIG_INTEGER_TYPE,
+    BIG_DECIMAL_TYPE;
+
+    private static Map<Class, ValueType> types = new HashMap<>();
+
+    static {
+        types.put(String.class, STRING_TYPE);
+        types.put(Byte.class, BYTE_TYPE);
+        types.put(Integer.class, INT_TYPE);
+        types.put(Long.class, LONG_TYPE);
+        types.put(Boolean.class, BOOL_TYPE);
+        types.put(QName.class, QNAME_TYPE);
+        types.put(Set.class, BITS_TYPE);
+        types.put(YangInstanceIdentifier.class, YANG_IDENTIFIER_TYPE);
+        types.put(Short.class,SHORT_TYPE);
+        types.put(BigInteger.class, BIG_INTEGER_TYPE);
+        types.put(BigDecimal.class, BIG_DECIMAL_TYPE);
+    }
+
+    public static final ValueType getSerializableType(Object node){
+        Preconditions.checkNotNull(node, "node should not be null");
+
+        if(types.containsKey(node.getClass())) {
+            return types.get(node.getClass());
+        } else if(node instanceof Set){
+            return BITS_TYPE;
+        }
+
+        throw new IllegalArgumentException("Unknown value type " + node.getClass().getSimpleName());
+    }
+}
index 35c2940..3926bc7 100644 (file)
@@ -799,23 +799,809 @@ public final class NormalizedNodeMessages {
     // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.Attribute)
   }
 
+  public interface PathArgumentAttributeOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // optional .org.opendaylight.controller.mdsal.QName name = 1;
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.QName name = 1;</code>
+     */
+    boolean hasName();
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.QName name = 1;</code>
+     */
+    org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName getName();
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.QName name = 1;</code>
+     */
+    org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QNameOrBuilder getNameOrBuilder();
+
+    // optional string value = 2;
+    /**
+     * <code>optional string value = 2;</code>
+     */
+    boolean hasValue();
+    /**
+     * <code>optional string value = 2;</code>
+     */
+    java.lang.String getValue();
+    /**
+     * <code>optional string value = 2;</code>
+     */
+    com.google.protobuf.ByteString
+        getValueBytes();
+
+    // optional int32 type = 3;
+    /**
+     * <code>optional int32 type = 3;</code>
+     */
+    boolean hasType();
+    /**
+     * <code>optional int32 type = 3;</code>
+     */
+    int getType();
+  }
+  /**
+   * Protobuf type {@code org.opendaylight.controller.mdsal.PathArgumentAttribute}
+   */
+  public static final class PathArgumentAttribute extends
+      com.google.protobuf.GeneratedMessage
+      implements PathArgumentAttributeOrBuilder {
+    // Use PathArgumentAttribute.newBuilder() to construct.
+    private PathArgumentAttribute(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private PathArgumentAttribute(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final PathArgumentAttribute defaultInstance;
+    public static PathArgumentAttribute getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public PathArgumentAttribute getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private PathArgumentAttribute(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 10: {
+              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000001) == 0x00000001)) {
+                subBuilder = name_.toBuilder();
+              }
+              name_ = input.readMessage(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(name_);
+                name_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000001;
+              break;
+            }
+            case 18: {
+              bitField0_ |= 0x00000002;
+              value_ = input.readBytes();
+              break;
+            }
+            case 24: {
+              bitField0_ |= 0x00000004;
+              type_ = input.readInt32();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.internal_static_org_opendaylight_controller_mdsal_PathArgumentAttribute_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.internal_static_org_opendaylight_controller_mdsal_PathArgumentAttribute_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.class, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<PathArgumentAttribute> PARSER =
+        new com.google.protobuf.AbstractParser<PathArgumentAttribute>() {
+      public PathArgumentAttribute parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new PathArgumentAttribute(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<PathArgumentAttribute> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // optional .org.opendaylight.controller.mdsal.QName name = 1;
+    public static final int NAME_FIELD_NUMBER = 1;
+    private org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName name_;
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.QName name = 1;</code>
+     */
+    public boolean hasName() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.QName name = 1;</code>
+     */
+    public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName getName() {
+      return name_;
+    }
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.QName name = 1;</code>
+     */
+    public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QNameOrBuilder getNameOrBuilder() {
+      return name_;
+    }
+
+    // optional string value = 2;
+    public static final int VALUE_FIELD_NUMBER = 2;
+    private java.lang.Object value_;
+    /**
+     * <code>optional string value = 2;</code>
+     */
+    public boolean hasValue() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>optional string value = 2;</code>
+     */
+    public java.lang.String getValue() {
+      java.lang.Object ref = value_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs =
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          value_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>optional string value = 2;</code>
+     */
+    public com.google.protobuf.ByteString
+        getValueBytes() {
+      java.lang.Object ref = value_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b =
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        value_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    // optional int32 type = 3;
+    public static final int TYPE_FIELD_NUMBER = 3;
+    private int type_;
+    /**
+     * <code>optional int32 type = 3;</code>
+     */
+    public boolean hasType() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>optional int32 type = 3;</code>
+     */
+    public int getType() {
+      return type_;
+    }
+
+    private void initFields() {
+      name_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.getDefaultInstance();
+      value_ = "";
+      type_ = 0;
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeMessage(1, name_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeBytes(2, getValueBytes());
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        output.writeInt32(3, type_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(1, name_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(2, getValueBytes());
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(3, type_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code org.opendaylight.controller.mdsal.PathArgumentAttribute}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttributeOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.internal_static_org_opendaylight_controller_mdsal_PathArgumentAttribute_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.internal_static_org_opendaylight_controller_mdsal_PathArgumentAttribute_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.class, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.Builder.class);
+      }
+
+      // Construct using org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+          getNameFieldBuilder();
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        if (nameBuilder_ == null) {
+          name_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.getDefaultInstance();
+        } else {
+          nameBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000001);
+        value_ = "";
+        bitField0_ = (bitField0_ & ~0x00000002);
+        type_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000004);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.internal_static_org_opendaylight_controller_mdsal_PathArgumentAttribute_descriptor;
+      }
+
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute getDefaultInstanceForType() {
+        return org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.getDefaultInstance();
+      }
+
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute build() {
+        org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute buildPartial() {
+        org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute result = new org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        if (nameBuilder_ == null) {
+          result.name_ = name_;
+        } else {
+          result.name_ = nameBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.value_ = value_;
+        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+          to_bitField0_ |= 0x00000004;
+        }
+        result.type_ = type_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute) {
+          return mergeFrom((org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute other) {
+        if (other == org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.getDefaultInstance()) return this;
+        if (other.hasName()) {
+          mergeName(other.getName());
+        }
+        if (other.hasValue()) {
+          bitField0_ |= 0x00000002;
+          value_ = other.value_;
+          onChanged();
+        }
+        if (other.hasType()) {
+          setType(other.getType());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // optional .org.opendaylight.controller.mdsal.QName name = 1;
+      private org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName name_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QNameOrBuilder> nameBuilder_;
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.QName name = 1;</code>
+       */
+      public boolean hasName() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.QName name = 1;</code>
+       */
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName getName() {
+        if (nameBuilder_ == null) {
+          return name_;
+        } else {
+          return nameBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.QName name = 1;</code>
+       */
+      public Builder setName(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName value) {
+        if (nameBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          name_ = value;
+          onChanged();
+        } else {
+          nameBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000001;
+        return this;
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.QName name = 1;</code>
+       */
+      public Builder setName(
+          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.Builder builderForValue) {
+        if (nameBuilder_ == null) {
+          name_ = builderForValue.build();
+          onChanged();
+        } else {
+          nameBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000001;
+        return this;
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.QName name = 1;</code>
+       */
+      public Builder mergeName(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName value) {
+        if (nameBuilder_ == null) {
+          if (((bitField0_ & 0x00000001) == 0x00000001) &&
+              name_ != org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.getDefaultInstance()) {
+            name_ =
+              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.newBuilder(name_).mergeFrom(value).buildPartial();
+          } else {
+            name_ = value;
+          }
+          onChanged();
+        } else {
+          nameBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000001;
+        return this;
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.QName name = 1;</code>
+       */
+      public Builder clearName() {
+        if (nameBuilder_ == null) {
+          name_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.getDefaultInstance();
+          onChanged();
+        } else {
+          nameBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000001);
+        return this;
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.QName name = 1;</code>
+       */
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.Builder getNameBuilder() {
+        bitField0_ |= 0x00000001;
+        onChanged();
+        return getNameFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.QName name = 1;</code>
+       */
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QNameOrBuilder getNameOrBuilder() {
+        if (nameBuilder_ != null) {
+          return nameBuilder_.getMessageOrBuilder();
+        } else {
+          return name_;
+        }
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.QName name = 1;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QNameOrBuilder>
+          getNameFieldBuilder() {
+        if (nameBuilder_ == null) {
+          nameBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QNameOrBuilder>(
+                  name_,
+                  getParentForChildren(),
+                  isClean());
+          name_ = null;
+        }
+        return nameBuilder_;
+      }
+
+      // optional string value = 2;
+      private java.lang.Object value_ = "";
+      /**
+       * <code>optional string value = 2;</code>
+       */
+      public boolean hasValue() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>optional string value = 2;</code>
+       */
+      public java.lang.String getValue() {
+        java.lang.Object ref = value_;
+        if (!(ref instanceof java.lang.String)) {
+          java.lang.String s = ((com.google.protobuf.ByteString) ref)
+              .toStringUtf8();
+          value_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>optional string value = 2;</code>
+       */
+      public com.google.protobuf.ByteString
+          getValueBytes() {
+        java.lang.Object ref = value_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b =
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          value_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>optional string value = 2;</code>
+       */
+      public Builder setValue(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        value_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string value = 2;</code>
+       */
+      public Builder clearValue() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        value_ = getDefaultInstance().getValue();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string value = 2;</code>
+       */
+      public Builder setValueBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        value_ = value;
+        onChanged();
+        return this;
+      }
+
+      // optional int32 type = 3;
+      private int type_ ;
+      /**
+       * <code>optional int32 type = 3;</code>
+       */
+      public boolean hasType() {
+        return ((bitField0_ & 0x00000004) == 0x00000004);
+      }
+      /**
+       * <code>optional int32 type = 3;</code>
+       */
+      public int getType() {
+        return type_;
+      }
+      /**
+       * <code>optional int32 type = 3;</code>
+       */
+      public Builder setType(int value) {
+        bitField0_ |= 0x00000004;
+        type_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional int32 type = 3;</code>
+       */
+      public Builder clearType() {
+        bitField0_ = (bitField0_ & ~0x00000004);
+        type_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.PathArgumentAttribute)
+    }
+
+    static {
+      defaultInstance = new PathArgumentAttribute(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.PathArgumentAttribute)
+  }
+
   public interface QNameOrBuilder
       extends com.google.protobuf.MessageOrBuilder {
 
-    // required string value = 1;
+    // optional string value = 1;
+    /**
+     * <code>optional string value = 1;</code>
+     *
+     * <pre>
+     * @deprecated
+     * </pre>
+     */
+    boolean hasValue();
+    /**
+     * <code>optional string value = 1;</code>
+     *
+     * <pre>
+     * @deprecated
+     * </pre>
+     */
+    java.lang.String getValue();
+    /**
+     * <code>optional string value = 1;</code>
+     *
+     * <pre>
+     * @deprecated
+     * </pre>
+     */
+    com.google.protobuf.ByteString
+        getValueBytes();
+
+    // optional int32 namespace = 2;
     /**
-     * <code>required string value = 1;</code>
+     * <code>optional int32 namespace = 2;</code>
      */
-    boolean hasValue();
+    boolean hasNamespace();
     /**
-     * <code>required string value = 1;</code>
+     * <code>optional int32 namespace = 2;</code>
      */
-    java.lang.String getValue();
+    int getNamespace();
+
+    // optional int32 revision = 3;
     /**
-     * <code>required string value = 1;</code>
+     * <code>optional int32 revision = 3;</code>
      */
-    com.google.protobuf.ByteString
-        getValueBytes();
+    boolean hasRevision();
+    /**
+     * <code>optional int32 revision = 3;</code>
+     */
+    int getRevision();
+
+    // optional int32 localName = 4;
+    /**
+     * <code>optional int32 localName = 4;</code>
+     */
+    boolean hasLocalName();
+    /**
+     * <code>optional int32 localName = 4;</code>
+     */
+    int getLocalName();
   }
   /**
    * Protobuf type {@code org.opendaylight.controller.mdsal.QName}
@@ -873,6 +1659,21 @@ public final class NormalizedNodeMessages {
               value_ = input.readBytes();
               break;
             }
+            case 16: {
+              bitField0_ |= 0x00000002;
+              namespace_ = input.readInt32();
+              break;
+            }
+            case 24: {
+              bitField0_ |= 0x00000004;
+              revision_ = input.readInt32();
+              break;
+            }
+            case 32: {
+              bitField0_ |= 0x00000008;
+              localName_ = input.readInt32();
+              break;
+            }
           }
         }
       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
@@ -913,17 +1714,25 @@ public final class NormalizedNodeMessages {
     }
 
     private int bitField0_;
-    // required string value = 1;
+    // optional string value = 1;
     public static final int VALUE_FIELD_NUMBER = 1;
     private java.lang.Object value_;
     /**
-     * <code>required string value = 1;</code>
+     * <code>optional string value = 1;</code>
+     *
+     * <pre>
+     * @deprecated
+     * </pre>
      */
     public boolean hasValue() {
       return ((bitField0_ & 0x00000001) == 0x00000001);
     }
     /**
-     * <code>required string value = 1;</code>
+     * <code>optional string value = 1;</code>
+     *
+     * <pre>
+     * @deprecated
+     * </pre>
      */
     public java.lang.String getValue() {
       java.lang.Object ref = value_;
@@ -940,7 +1749,11 @@ public final class NormalizedNodeMessages {
       }
     }
     /**
-     * <code>required string value = 1;</code>
+     * <code>optional string value = 1;</code>
+     *
+     * <pre>
+     * @deprecated
+     * </pre>
      */
     public com.google.protobuf.ByteString
         getValueBytes() {
@@ -956,18 +1769,65 @@ public final class NormalizedNodeMessages {
       }
     }
 
+    // optional int32 namespace = 2;
+    public static final int NAMESPACE_FIELD_NUMBER = 2;
+    private int namespace_;
+    /**
+     * <code>optional int32 namespace = 2;</code>
+     */
+    public boolean hasNamespace() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>optional int32 namespace = 2;</code>
+     */
+    public int getNamespace() {
+      return namespace_;
+    }
+
+    // optional int32 revision = 3;
+    public static final int REVISION_FIELD_NUMBER = 3;
+    private int revision_;
+    /**
+     * <code>optional int32 revision = 3;</code>
+     */
+    public boolean hasRevision() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>optional int32 revision = 3;</code>
+     */
+    public int getRevision() {
+      return revision_;
+    }
+
+    // optional int32 localName = 4;
+    public static final int LOCALNAME_FIELD_NUMBER = 4;
+    private int localName_;
+    /**
+     * <code>optional int32 localName = 4;</code>
+     */
+    public boolean hasLocalName() {
+      return ((bitField0_ & 0x00000008) == 0x00000008);
+    }
+    /**
+     * <code>optional int32 localName = 4;</code>
+     */
+    public int getLocalName() {
+      return localName_;
+    }
+
     private void initFields() {
       value_ = "";
+      namespace_ = 0;
+      revision_ = 0;
+      localName_ = 0;
     }
     private byte memoizedIsInitialized = -1;
     public final boolean isInitialized() {
       byte isInitialized = memoizedIsInitialized;
       if (isInitialized != -1) return isInitialized == 1;
 
-      if (!hasValue()) {
-        memoizedIsInitialized = 0;
-        return false;
-      }
       memoizedIsInitialized = 1;
       return true;
     }
@@ -978,6 +1838,15 @@ public final class NormalizedNodeMessages {
       if (((bitField0_ & 0x00000001) == 0x00000001)) {
         output.writeBytes(1, getValueBytes());
       }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeInt32(2, namespace_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        output.writeInt32(3, revision_);
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        output.writeInt32(4, localName_);
+      }
       getUnknownFields().writeTo(output);
     }
 
@@ -991,6 +1860,18 @@ public final class NormalizedNodeMessages {
         size += com.google.protobuf.CodedOutputStream
           .computeBytesSize(1, getValueBytes());
       }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(2, namespace_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(3, revision_);
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(4, localName_);
+      }
       size += getUnknownFields().getSerializedSize();
       memoizedSerializedSize = size;
       return size;
@@ -1109,6 +1990,12 @@ public final class NormalizedNodeMessages {
         super.clear();
         value_ = "";
         bitField0_ = (bitField0_ & ~0x00000001);
+        namespace_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000002);
+        revision_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000004);
+        localName_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000008);
         return this;
       }
 
@@ -1141,6 +2028,18 @@ public final class NormalizedNodeMessages {
           to_bitField0_ |= 0x00000001;
         }
         result.value_ = value_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.namespace_ = namespace_;
+        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+          to_bitField0_ |= 0x00000004;
+        }
+        result.revision_ = revision_;
+        if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+          to_bitField0_ |= 0x00000008;
+        }
+        result.localName_ = localName_;
         result.bitField0_ = to_bitField0_;
         onBuilt();
         return result;
@@ -1162,15 +2061,20 @@ public final class NormalizedNodeMessages {
           value_ = other.value_;
           onChanged();
         }
+        if (other.hasNamespace()) {
+          setNamespace(other.getNamespace());
+        }
+        if (other.hasRevision()) {
+          setRevision(other.getRevision());
+        }
+        if (other.hasLocalName()) {
+          setLocalName(other.getLocalName());
+        }
         this.mergeUnknownFields(other.getUnknownFields());
         return this;
       }
 
       public final boolean isInitialized() {
-        if (!hasValue()) {
-
-          return false;
-        }
         return true;
       }
 
@@ -1193,16 +2097,24 @@ public final class NormalizedNodeMessages {
       }
       private int bitField0_;
 
-      // required string value = 1;
+      // optional string value = 1;
       private java.lang.Object value_ = "";
       /**
-       * <code>required string value = 1;</code>
+       * <code>optional string value = 1;</code>
+       *
+       * <pre>
+       * @deprecated
+       * </pre>
        */
       public boolean hasValue() {
         return ((bitField0_ & 0x00000001) == 0x00000001);
       }
       /**
-       * <code>required string value = 1;</code>
+       * <code>optional string value = 1;</code>
+       *
+       * <pre>
+       * @deprecated
+       * </pre>
        */
       public java.lang.String getValue() {
         java.lang.Object ref = value_;
@@ -1216,7 +2128,11 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>required string value = 1;</code>
+       * <code>optional string value = 1;</code>
+       *
+       * <pre>
+       * @deprecated
+       * </pre>
        */
       public com.google.protobuf.ByteString
           getValueBytes() {
@@ -1232,7 +2148,11 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>required string value = 1;</code>
+       * <code>optional string value = 1;</code>
+       *
+       * <pre>
+       * @deprecated
+       * </pre>
        */
       public Builder setValue(
           java.lang.String value) {
@@ -1245,7 +2165,11 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>required string value = 1;</code>
+       * <code>optional string value = 1;</code>
+       *
+       * <pre>
+       * @deprecated
+       * </pre>
        */
       public Builder clearValue() {
         bitField0_ = (bitField0_ & ~0x00000001);
@@ -1254,7 +2178,11 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>required string value = 1;</code>
+       * <code>optional string value = 1;</code>
+       *
+       * <pre>
+       * @deprecated
+       * </pre>
        */
       public Builder setValueBytes(
           com.google.protobuf.ByteString value) {
@@ -1267,6 +2195,105 @@ public final class NormalizedNodeMessages {
         return this;
       }
 
+      // optional int32 namespace = 2;
+      private int namespace_ ;
+      /**
+       * <code>optional int32 namespace = 2;</code>
+       */
+      public boolean hasNamespace() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>optional int32 namespace = 2;</code>
+       */
+      public int getNamespace() {
+        return namespace_;
+      }
+      /**
+       * <code>optional int32 namespace = 2;</code>
+       */
+      public Builder setNamespace(int value) {
+        bitField0_ |= 0x00000002;
+        namespace_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional int32 namespace = 2;</code>
+       */
+      public Builder clearNamespace() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        namespace_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // optional int32 revision = 3;
+      private int revision_ ;
+      /**
+       * <code>optional int32 revision = 3;</code>
+       */
+      public boolean hasRevision() {
+        return ((bitField0_ & 0x00000004) == 0x00000004);
+      }
+      /**
+       * <code>optional int32 revision = 3;</code>
+       */
+      public int getRevision() {
+        return revision_;
+      }
+      /**
+       * <code>optional int32 revision = 3;</code>
+       */
+      public Builder setRevision(int value) {
+        bitField0_ |= 0x00000004;
+        revision_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional int32 revision = 3;</code>
+       */
+      public Builder clearRevision() {
+        bitField0_ = (bitField0_ & ~0x00000004);
+        revision_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // optional int32 localName = 4;
+      private int localName_ ;
+      /**
+       * <code>optional int32 localName = 4;</code>
+       */
+      public boolean hasLocalName() {
+        return ((bitField0_ & 0x00000008) == 0x00000008);
+      }
+      /**
+       * <code>optional int32 localName = 4;</code>
+       */
+      public int getLocalName() {
+        return localName_;
+      }
+      /**
+       * <code>optional int32 localName = 4;</code>
+       */
+      public Builder setLocalName(int value) {
+        bitField0_ |= 0x00000008;
+        localName_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional int32 localName = 4;</code>
+       */
+      public Builder clearLocalName() {
+        bitField0_ = (bitField0_ & ~0x00000008);
+        localName_ = 0;
+        onChanged();
+        return this;
+      }
+
       // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.QName)
     }
 
@@ -1281,17 +2308,29 @@ public final class NormalizedNodeMessages {
   public interface PathArgumentOrBuilder
       extends com.google.protobuf.MessageOrBuilder {
 
-    // required string value = 1;
+    // optional string value = 1;
     /**
-     * <code>required string value = 1;</code>
+     * <code>optional string value = 1;</code>
+     *
+     * <pre>
+     * @deprecated
+     * </pre>
      */
     boolean hasValue();
     /**
-     * <code>required string value = 1;</code>
+     * <code>optional string value = 1;</code>
+     *
+     * <pre>
+     * @deprecated
+     * </pre>
      */
     java.lang.String getValue();
     /**
-     * <code>required string value = 1;</code>
+     * <code>optional string value = 1;</code>
+     *
+     * <pre>
+     * @deprecated
+     * </pre>
      */
     com.google.protobuf.ByteString
         getValueBytes();
@@ -1301,7 +2340,7 @@ public final class NormalizedNodeMessages {
      * <code>optional string type = 2;</code>
      *
      * <pre>
-     *NodeIdentifier, NodeWithValue, NodeIdentifierWithPredicates
+     * @deprecated
      * </pre>
      */
     boolean hasType();
@@ -1309,7 +2348,7 @@ public final class NormalizedNodeMessages {
      * <code>optional string type = 2;</code>
      *
      * <pre>
-     *NodeIdentifier, NodeWithValue, NodeIdentifierWithPredicates
+     * @deprecated
      * </pre>
      */
     java.lang.String getType();
@@ -1317,7 +2356,7 @@ public final class NormalizedNodeMessages {
      * <code>optional string type = 2;</code>
      *
      * <pre>
-     *NodeIdentifier, NodeWithValue, NodeIdentifierWithPredicates
+     * @deprecated
      * </pre>
      */
     com.google.protobuf.ByteString
@@ -1337,30 +2376,85 @@ public final class NormalizedNodeMessages {
      */
     org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QNameOrBuilder getNodeTypeOrBuilder();
 
-    // repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;
+    // repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;
+    /**
+     * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+     */
+    java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute>
+        getAttributeList();
+    /**
+     * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+     */
+    org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute getAttribute(int index);
+    /**
+     * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+     */
+    int getAttributeCount();
+    /**
+     * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+     */
+    java.util.List<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttributeOrBuilder>
+        getAttributeOrBuilderList();
+    /**
+     * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+     */
+    org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttributeOrBuilder getAttributeOrBuilder(
+        int index);
+
+    // repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+     *
+     * <pre>
+     * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+     * </pre>
      */
     java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute>
         getAttributesList();
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+     *
+     * <pre>
+     * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+     * </pre>
      */
     org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute getAttributes(int index);
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+     *
+     * <pre>
+     * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+     * </pre>
      */
     int getAttributesCount();
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+     *
+     * <pre>
+     * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+     * </pre>
      */
     java.util.List<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder>
         getAttributesOrBuilderList();
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+     *
+     * <pre>
+     * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+     * </pre>
      */
     org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder getAttributesOrBuilder(
         int index);
+
+    // optional int32 intType = 6;
+    /**
+     * <code>optional int32 intType = 6;</code>
+     */
+    boolean hasIntType();
+    /**
+     * <code>optional int32 intType = 6;</code>
+     */
+    int getIntType();
   }
   /**
    * Protobuf type {@code org.opendaylight.controller.mdsal.PathArgument}
@@ -1438,12 +2532,25 @@ public final class NormalizedNodeMessages {
             }
             case 34: {
               if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
-                attributes_ = new java.util.ArrayList<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute>();
+                attribute_ = new java.util.ArrayList<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute>();
                 mutable_bitField0_ |= 0x00000008;
               }
+              attribute_.add(input.readMessage(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.PARSER, extensionRegistry));
+              break;
+            }
+            case 42: {
+              if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
+                attributes_ = new java.util.ArrayList<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute>();
+                mutable_bitField0_ |= 0x00000010;
+              }
               attributes_.add(input.readMessage(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.PARSER, extensionRegistry));
               break;
             }
+            case 48: {
+              bitField0_ |= 0x00000008;
+              intType_ = input.readInt32();
+              break;
+            }
           }
         }
       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
@@ -1453,6 +2560,9 @@ public final class NormalizedNodeMessages {
             e.getMessage()).setUnfinishedMessage(this);
       } finally {
         if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
+          attribute_ = java.util.Collections.unmodifiableList(attribute_);
+        }
+        if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
           attributes_ = java.util.Collections.unmodifiableList(attributes_);
         }
         this.unknownFields = unknownFields.build();
@@ -1487,17 +2597,25 @@ public final class NormalizedNodeMessages {
     }
 
     private int bitField0_;
-    // required string value = 1;
+    // optional string value = 1;
     public static final int VALUE_FIELD_NUMBER = 1;
     private java.lang.Object value_;
     /**
-     * <code>required string value = 1;</code>
+     * <code>optional string value = 1;</code>
+     *
+     * <pre>
+     * @deprecated
+     * </pre>
      */
     public boolean hasValue() {
       return ((bitField0_ & 0x00000001) == 0x00000001);
     }
     /**
-     * <code>required string value = 1;</code>
+     * <code>optional string value = 1;</code>
+     *
+     * <pre>
+     * @deprecated
+     * </pre>
      */
     public java.lang.String getValue() {
       java.lang.Object ref = value_;
@@ -1514,7 +2632,11 @@ public final class NormalizedNodeMessages {
       }
     }
     /**
-     * <code>required string value = 1;</code>
+     * <code>optional string value = 1;</code>
+     *
+     * <pre>
+     * @deprecated
+     * </pre>
      */
     public com.google.protobuf.ByteString
         getValueBytes() {
@@ -1537,7 +2659,7 @@ public final class NormalizedNodeMessages {
      * <code>optional string type = 2;</code>
      *
      * <pre>
-     *NodeIdentifier, NodeWithValue, NodeIdentifierWithPredicates
+     * @deprecated
      * </pre>
      */
     public boolean hasType() {
@@ -1547,7 +2669,7 @@ public final class NormalizedNodeMessages {
      * <code>optional string type = 2;</code>
      *
      * <pre>
-     *NodeIdentifier, NodeWithValue, NodeIdentifierWithPredicates
+     * @deprecated
      * </pre>
      */
     public java.lang.String getType() {
@@ -1568,7 +2690,7 @@ public final class NormalizedNodeMessages {
      * <code>optional string type = 2;</code>
      *
      * <pre>
-     *NodeIdentifier, NodeWithValue, NodeIdentifierWithPredicates
+     * @deprecated
      * </pre>
      */
     public com.google.protobuf.ByteString
@@ -1584,86 +2706,150 @@ public final class NormalizedNodeMessages {
         return (com.google.protobuf.ByteString) ref;
       }
     }
-
-    // optional .org.opendaylight.controller.mdsal.QName nodeType = 3;
-    public static final int NODETYPE_FIELD_NUMBER = 3;
-    private org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName nodeType_;
+
+    // optional .org.opendaylight.controller.mdsal.QName nodeType = 3;
+    public static final int NODETYPE_FIELD_NUMBER = 3;
+    private org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName nodeType_;
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+     */
+    public boolean hasNodeType() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+     */
+    public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName getNodeType() {
+      return nodeType_;
+    }
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+     */
+    public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QNameOrBuilder getNodeTypeOrBuilder() {
+      return nodeType_;
+    }
+
+    // repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;
+    public static final int ATTRIBUTE_FIELD_NUMBER = 4;
+    private java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute> attribute_;
+    /**
+     * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+     */
+    public java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute> getAttributeList() {
+      return attribute_;
+    }
+    /**
+     * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+     */
+    public java.util.List<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttributeOrBuilder>
+        getAttributeOrBuilderList() {
+      return attribute_;
+    }
     /**
-     * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
      */
-    public boolean hasNodeType() {
-      return ((bitField0_ & 0x00000004) == 0x00000004);
+    public int getAttributeCount() {
+      return attribute_.size();
     }
     /**
-     * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
      */
-    public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName getNodeType() {
-      return nodeType_;
+    public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute getAttribute(int index) {
+      return attribute_.get(index);
     }
     /**
-     * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
      */
-    public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QNameOrBuilder getNodeTypeOrBuilder() {
-      return nodeType_;
+    public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttributeOrBuilder getAttributeOrBuilder(
+        int index) {
+      return attribute_.get(index);
     }
 
-    // repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;
-    public static final int ATTRIBUTES_FIELD_NUMBER = 4;
+    // repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;
+    public static final int ATTRIBUTES_FIELD_NUMBER = 5;
     private java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute> attributes_;
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+     *
+     * <pre>
+     * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+     * </pre>
      */
     public java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute> getAttributesList() {
       return attributes_;
     }
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+     *
+     * <pre>
+     * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+     * </pre>
      */
     public java.util.List<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder>
         getAttributesOrBuilderList() {
       return attributes_;
     }
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+     *
+     * <pre>
+     * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+     * </pre>
      */
     public int getAttributesCount() {
       return attributes_.size();
     }
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+     *
+     * <pre>
+     * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+     * </pre>
      */
     public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute getAttributes(int index) {
       return attributes_.get(index);
     }
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+     *
+     * <pre>
+     * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+     * </pre>
      */
     public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder getAttributesOrBuilder(
         int index) {
       return attributes_.get(index);
     }
 
+    // optional int32 intType = 6;
+    public static final int INTTYPE_FIELD_NUMBER = 6;
+    private int intType_;
+    /**
+     * <code>optional int32 intType = 6;</code>
+     */
+    public boolean hasIntType() {
+      return ((bitField0_ & 0x00000008) == 0x00000008);
+    }
+    /**
+     * <code>optional int32 intType = 6;</code>
+     */
+    public int getIntType() {
+      return intType_;
+    }
+
     private void initFields() {
       value_ = "";
       type_ = "";
       nodeType_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.getDefaultInstance();
+      attribute_ = java.util.Collections.emptyList();
       attributes_ = java.util.Collections.emptyList();
+      intType_ = 0;
     }
     private byte memoizedIsInitialized = -1;
     public final boolean isInitialized() {
       byte isInitialized = memoizedIsInitialized;
       if (isInitialized != -1) return isInitialized == 1;
 
-      if (!hasValue()) {
-        memoizedIsInitialized = 0;
-        return false;
-      }
-      if (hasNodeType()) {
-        if (!getNodeType().isInitialized()) {
-          memoizedIsInitialized = 0;
-          return false;
-        }
-      }
       for (int i = 0; i < getAttributesCount(); i++) {
         if (!getAttributes(i).isInitialized()) {
           memoizedIsInitialized = 0;
@@ -1686,8 +2872,14 @@ public final class NormalizedNodeMessages {
       if (((bitField0_ & 0x00000004) == 0x00000004)) {
         output.writeMessage(3, nodeType_);
       }
+      for (int i = 0; i < attribute_.size(); i++) {
+        output.writeMessage(4, attribute_.get(i));
+      }
       for (int i = 0; i < attributes_.size(); i++) {
-        output.writeMessage(4, attributes_.get(i));
+        output.writeMessage(5, attributes_.get(i));
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        output.writeInt32(6, intType_);
       }
       getUnknownFields().writeTo(output);
     }
@@ -1710,9 +2902,17 @@ public final class NormalizedNodeMessages {
         size += com.google.protobuf.CodedOutputStream
           .computeMessageSize(3, nodeType_);
       }
+      for (int i = 0; i < attribute_.size(); i++) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(4, attribute_.get(i));
+      }
       for (int i = 0; i < attributes_.size(); i++) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(4, attributes_.get(i));
+          .computeMessageSize(5, attributes_.get(i));
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(6, intType_);
       }
       size += getUnknownFields().getSerializedSize();
       memoizedSerializedSize = size;
@@ -1823,6 +3023,7 @@ public final class NormalizedNodeMessages {
       private void maybeForceBuilderInitialization() {
         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
           getNodeTypeFieldBuilder();
+          getAttributeFieldBuilder();
           getAttributesFieldBuilder();
         }
       }
@@ -1842,12 +3043,20 @@ public final class NormalizedNodeMessages {
           nodeTypeBuilder_.clear();
         }
         bitField0_ = (bitField0_ & ~0x00000004);
+        if (attributeBuilder_ == null) {
+          attribute_ = java.util.Collections.emptyList();
+          bitField0_ = (bitField0_ & ~0x00000008);
+        } else {
+          attributeBuilder_.clear();
+        }
         if (attributesBuilder_ == null) {
           attributes_ = java.util.Collections.emptyList();
-          bitField0_ = (bitField0_ & ~0x00000008);
+          bitField0_ = (bitField0_ & ~0x00000010);
         } else {
           attributesBuilder_.clear();
         }
+        intType_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000020);
         return this;
       }
 
@@ -1892,15 +3101,28 @@ public final class NormalizedNodeMessages {
         } else {
           result.nodeType_ = nodeTypeBuilder_.build();
         }
-        if (attributesBuilder_ == null) {
+        if (attributeBuilder_ == null) {
           if (((bitField0_ & 0x00000008) == 0x00000008)) {
-            attributes_ = java.util.Collections.unmodifiableList(attributes_);
+            attribute_ = java.util.Collections.unmodifiableList(attribute_);
             bitField0_ = (bitField0_ & ~0x00000008);
           }
+          result.attribute_ = attribute_;
+        } else {
+          result.attribute_ = attributeBuilder_.build();
+        }
+        if (attributesBuilder_ == null) {
+          if (((bitField0_ & 0x00000010) == 0x00000010)) {
+            attributes_ = java.util.Collections.unmodifiableList(attributes_);
+            bitField0_ = (bitField0_ & ~0x00000010);
+          }
           result.attributes_ = attributes_;
         } else {
           result.attributes_ = attributesBuilder_.build();
         }
+        if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
+          to_bitField0_ |= 0x00000008;
+        }
+        result.intType_ = intType_;
         result.bitField0_ = to_bitField0_;
         onBuilt();
         return result;
@@ -1930,11 +3152,37 @@ public final class NormalizedNodeMessages {
         if (other.hasNodeType()) {
           mergeNodeType(other.getNodeType());
         }
+        if (attributeBuilder_ == null) {
+          if (!other.attribute_.isEmpty()) {
+            if (attribute_.isEmpty()) {
+              attribute_ = other.attribute_;
+              bitField0_ = (bitField0_ & ~0x00000008);
+            } else {
+              ensureAttributeIsMutable();
+              attribute_.addAll(other.attribute_);
+            }
+            onChanged();
+          }
+        } else {
+          if (!other.attribute_.isEmpty()) {
+            if (attributeBuilder_.isEmpty()) {
+              attributeBuilder_.dispose();
+              attributeBuilder_ = null;
+              attribute_ = other.attribute_;
+              bitField0_ = (bitField0_ & ~0x00000008);
+              attributeBuilder_ =
+                com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
+                   getAttributeFieldBuilder() : null;
+            } else {
+              attributeBuilder_.addAllMessages(other.attribute_);
+            }
+          }
+        }
         if (attributesBuilder_ == null) {
           if (!other.attributes_.isEmpty()) {
             if (attributes_.isEmpty()) {
               attributes_ = other.attributes_;
-              bitField0_ = (bitField0_ & ~0x00000008);
+              bitField0_ = (bitField0_ & ~0x00000010);
             } else {
               ensureAttributesIsMutable();
               attributes_.addAll(other.attributes_);
@@ -1947,7 +3195,7 @@ public final class NormalizedNodeMessages {
               attributesBuilder_.dispose();
               attributesBuilder_ = null;
               attributes_ = other.attributes_;
-              bitField0_ = (bitField0_ & ~0x00000008);
+              bitField0_ = (bitField0_ & ~0x00000010);
               attributesBuilder_ =
                 com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
                    getAttributesFieldBuilder() : null;
@@ -1956,21 +3204,14 @@ public final class NormalizedNodeMessages {
             }
           }
         }
+        if (other.hasIntType()) {
+          setIntType(other.getIntType());
+        }
         this.mergeUnknownFields(other.getUnknownFields());
         return this;
       }
 
       public final boolean isInitialized() {
-        if (!hasValue()) {
-
-          return false;
-        }
-        if (hasNodeType()) {
-          if (!getNodeType().isInitialized()) {
-
-            return false;
-          }
-        }
         for (int i = 0; i < getAttributesCount(); i++) {
           if (!getAttributes(i).isInitialized()) {
 
@@ -1999,16 +3240,24 @@ public final class NormalizedNodeMessages {
       }
       private int bitField0_;
 
-      // required string value = 1;
+      // optional string value = 1;
       private java.lang.Object value_ = "";
       /**
-       * <code>required string value = 1;</code>
+       * <code>optional string value = 1;</code>
+       *
+       * <pre>
+       * @deprecated
+       * </pre>
        */
       public boolean hasValue() {
         return ((bitField0_ & 0x00000001) == 0x00000001);
       }
       /**
-       * <code>required string value = 1;</code>
+       * <code>optional string value = 1;</code>
+       *
+       * <pre>
+       * @deprecated
+       * </pre>
        */
       public java.lang.String getValue() {
         java.lang.Object ref = value_;
@@ -2022,7 +3271,11 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>required string value = 1;</code>
+       * <code>optional string value = 1;</code>
+       *
+       * <pre>
+       * @deprecated
+       * </pre>
        */
       public com.google.protobuf.ByteString
           getValueBytes() {
@@ -2038,7 +3291,11 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>required string value = 1;</code>
+       * <code>optional string value = 1;</code>
+       *
+       * <pre>
+       * @deprecated
+       * </pre>
        */
       public Builder setValue(
           java.lang.String value) {
@@ -2051,7 +3308,11 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>required string value = 1;</code>
+       * <code>optional string value = 1;</code>
+       *
+       * <pre>
+       * @deprecated
+       * </pre>
        */
       public Builder clearValue() {
         bitField0_ = (bitField0_ & ~0x00000001);
@@ -2060,7 +3321,11 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>required string value = 1;</code>
+       * <code>optional string value = 1;</code>
+       *
+       * <pre>
+       * @deprecated
+       * </pre>
        */
       public Builder setValueBytes(
           com.google.protobuf.ByteString value) {
@@ -2079,7 +3344,7 @@ public final class NormalizedNodeMessages {
        * <code>optional string type = 2;</code>
        *
        * <pre>
-       *NodeIdentifier, NodeWithValue, NodeIdentifierWithPredicates
+       * @deprecated
        * </pre>
        */
       public boolean hasType() {
@@ -2089,7 +3354,7 @@ public final class NormalizedNodeMessages {
        * <code>optional string type = 2;</code>
        *
        * <pre>
-       *NodeIdentifier, NodeWithValue, NodeIdentifierWithPredicates
+       * @deprecated
        * </pre>
        */
       public java.lang.String getType() {
@@ -2107,7 +3372,7 @@ public final class NormalizedNodeMessages {
        * <code>optional string type = 2;</code>
        *
        * <pre>
-       *NodeIdentifier, NodeWithValue, NodeIdentifierWithPredicates
+       * @deprecated
        * </pre>
        */
       public com.google.protobuf.ByteString
@@ -2127,7 +3392,7 @@ public final class NormalizedNodeMessages {
        * <code>optional string type = 2;</code>
        *
        * <pre>
-       *NodeIdentifier, NodeWithValue, NodeIdentifierWithPredicates
+       * @deprecated
        * </pre>
        */
       public Builder setType(
@@ -2144,7 +3409,7 @@ public final class NormalizedNodeMessages {
        * <code>optional string type = 2;</code>
        *
        * <pre>
-       *NodeIdentifier, NodeWithValue, NodeIdentifierWithPredicates
+       * @deprecated
        * </pre>
        */
       public Builder clearType() {
@@ -2157,7 +3422,7 @@ public final class NormalizedNodeMessages {
        * <code>optional string type = 2;</code>
        *
        * <pre>
-       *NodeIdentifier, NodeWithValue, NodeIdentifierWithPredicates
+       * @deprecated
        * </pre>
        */
       public Builder setTypeBytes(
@@ -2216,85 +3481,325 @@ public final class NormalizedNodeMessages {
           nodeType_ = builderForValue.build();
           onChanged();
         } else {
-          nodeTypeBuilder_.setMessage(builderForValue.build());
+          nodeTypeBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000004;
+        return this;
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+       */
+      public Builder mergeNodeType(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName value) {
+        if (nodeTypeBuilder_ == null) {
+          if (((bitField0_ & 0x00000004) == 0x00000004) &&
+              nodeType_ != org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.getDefaultInstance()) {
+            nodeType_ =
+              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.newBuilder(nodeType_).mergeFrom(value).buildPartial();
+          } else {
+            nodeType_ = value;
+          }
+          onChanged();
+        } else {
+          nodeTypeBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000004;
+        return this;
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+       */
+      public Builder clearNodeType() {
+        if (nodeTypeBuilder_ == null) {
+          nodeType_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.getDefaultInstance();
+          onChanged();
+        } else {
+          nodeTypeBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000004);
+        return this;
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+       */
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.Builder getNodeTypeBuilder() {
+        bitField0_ |= 0x00000004;
+        onChanged();
+        return getNodeTypeFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+       */
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QNameOrBuilder getNodeTypeOrBuilder() {
+        if (nodeTypeBuilder_ != null) {
+          return nodeTypeBuilder_.getMessageOrBuilder();
+        } else {
+          return nodeType_;
+        }
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QNameOrBuilder>
+          getNodeTypeFieldBuilder() {
+        if (nodeTypeBuilder_ == null) {
+          nodeTypeBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QNameOrBuilder>(
+                  nodeType_,
+                  getParentForChildren(),
+                  isClean());
+          nodeType_ = null;
+        }
+        return nodeTypeBuilder_;
+      }
+
+      // repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;
+      private java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute> attribute_ =
+        java.util.Collections.emptyList();
+      private void ensureAttributeIsMutable() {
+        if (!((bitField0_ & 0x00000008) == 0x00000008)) {
+          attribute_ = new java.util.ArrayList<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute>(attribute_);
+          bitField0_ |= 0x00000008;
+         }
+      }
+
+      private com.google.protobuf.RepeatedFieldBuilder<
+          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttributeOrBuilder> attributeBuilder_;
+
+      /**
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+       */
+      public java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute> getAttributeList() {
+        if (attributeBuilder_ == null) {
+          return java.util.Collections.unmodifiableList(attribute_);
+        } else {
+          return attributeBuilder_.getMessageList();
+        }
+      }
+      /**
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+       */
+      public int getAttributeCount() {
+        if (attributeBuilder_ == null) {
+          return attribute_.size();
+        } else {
+          return attributeBuilder_.getCount();
+        }
+      }
+      /**
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+       */
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute getAttribute(int index) {
+        if (attributeBuilder_ == null) {
+          return attribute_.get(index);
+        } else {
+          return attributeBuilder_.getMessage(index);
+        }
+      }
+      /**
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+       */
+      public Builder setAttribute(
+          int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute value) {
+        if (attributeBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureAttributeIsMutable();
+          attribute_.set(index, value);
+          onChanged();
+        } else {
+          attributeBuilder_.setMessage(index, value);
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+       */
+      public Builder setAttribute(
+          int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.Builder builderForValue) {
+        if (attributeBuilder_ == null) {
+          ensureAttributeIsMutable();
+          attribute_.set(index, builderForValue.build());
+          onChanged();
+        } else {
+          attributeBuilder_.setMessage(index, builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+       */
+      public Builder addAttribute(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute value) {
+        if (attributeBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureAttributeIsMutable();
+          attribute_.add(value);
+          onChanged();
+        } else {
+          attributeBuilder_.addMessage(value);
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+       */
+      public Builder addAttribute(
+          int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute value) {
+        if (attributeBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureAttributeIsMutable();
+          attribute_.add(index, value);
+          onChanged();
+        } else {
+          attributeBuilder_.addMessage(index, value);
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+       */
+      public Builder addAttribute(
+          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.Builder builderForValue) {
+        if (attributeBuilder_ == null) {
+          ensureAttributeIsMutable();
+          attribute_.add(builderForValue.build());
+          onChanged();
+        } else {
+          attributeBuilder_.addMessage(builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+       */
+      public Builder addAttribute(
+          int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.Builder builderForValue) {
+        if (attributeBuilder_ == null) {
+          ensureAttributeIsMutable();
+          attribute_.add(index, builderForValue.build());
+          onChanged();
+        } else {
+          attributeBuilder_.addMessage(index, builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+       */
+      public Builder addAllAttribute(
+          java.lang.Iterable<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute> values) {
+        if (attributeBuilder_ == null) {
+          ensureAttributeIsMutable();
+          super.addAll(values, attribute_);
+          onChanged();
+        } else {
+          attributeBuilder_.addAllMessages(values);
         }
-        bitField0_ |= 0x00000004;
         return this;
       }
       /**
-       * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
        */
-      public Builder mergeNodeType(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName value) {
-        if (nodeTypeBuilder_ == null) {
-          if (((bitField0_ & 0x00000004) == 0x00000004) &&
-              nodeType_ != org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.getDefaultInstance()) {
-            nodeType_ =
-              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.newBuilder(nodeType_).mergeFrom(value).buildPartial();
-          } else {
-            nodeType_ = value;
-          }
+      public Builder clearAttribute() {
+        if (attributeBuilder_ == null) {
+          attribute_ = java.util.Collections.emptyList();
+          bitField0_ = (bitField0_ & ~0x00000008);
           onChanged();
         } else {
-          nodeTypeBuilder_.mergeFrom(value);
+          attributeBuilder_.clear();
         }
-        bitField0_ |= 0x00000004;
         return this;
       }
       /**
-       * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
        */
-      public Builder clearNodeType() {
-        if (nodeTypeBuilder_ == null) {
-          nodeType_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.getDefaultInstance();
+      public Builder removeAttribute(int index) {
+        if (attributeBuilder_ == null) {
+          ensureAttributeIsMutable();
+          attribute_.remove(index);
           onChanged();
         } else {
-          nodeTypeBuilder_.clear();
+          attributeBuilder_.remove(index);
         }
-        bitField0_ = (bitField0_ & ~0x00000004);
         return this;
       }
       /**
-       * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
        */
-      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.Builder getNodeTypeBuilder() {
-        bitField0_ |= 0x00000004;
-        onChanged();
-        return getNodeTypeFieldBuilder().getBuilder();
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.Builder getAttributeBuilder(
+          int index) {
+        return getAttributeFieldBuilder().getBuilder(index);
       }
       /**
-       * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
        */
-      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QNameOrBuilder getNodeTypeOrBuilder() {
-        if (nodeTypeBuilder_ != null) {
-          return nodeTypeBuilder_.getMessageOrBuilder();
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttributeOrBuilder getAttributeOrBuilder(
+          int index) {
+        if (attributeBuilder_ == null) {
+          return attribute_.get(index);  } else {
+          return attributeBuilder_.getMessageOrBuilder(index);
+        }
+      }
+      /**
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+       */
+      public java.util.List<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttributeOrBuilder>
+           getAttributeOrBuilderList() {
+        if (attributeBuilder_ != null) {
+          return attributeBuilder_.getMessageOrBuilderList();
         } else {
-          return nodeType_;
+          return java.util.Collections.unmodifiableList(attribute_);
         }
       }
       /**
-       * <code>optional .org.opendaylight.controller.mdsal.QName nodeType = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
        */
-      private com.google.protobuf.SingleFieldBuilder<
-          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QNameOrBuilder>
-          getNodeTypeFieldBuilder() {
-        if (nodeTypeBuilder_ == null) {
-          nodeTypeBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QName.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.QNameOrBuilder>(
-                  nodeType_,
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.Builder addAttributeBuilder() {
+        return getAttributeFieldBuilder().addBuilder(
+            org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.getDefaultInstance());
+      }
+      /**
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+       */
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.Builder addAttributeBuilder(
+          int index) {
+        return getAttributeFieldBuilder().addBuilder(
+            index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.getDefaultInstance());
+      }
+      /**
+       * <code>repeated .org.opendaylight.controller.mdsal.PathArgumentAttribute attribute = 4;</code>
+       */
+      public java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.Builder>
+           getAttributeBuilderList() {
+        return getAttributeFieldBuilder().getBuilderList();
+      }
+      private com.google.protobuf.RepeatedFieldBuilder<
+          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttributeOrBuilder>
+          getAttributeFieldBuilder() {
+        if (attributeBuilder_ == null) {
+          attributeBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
+              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttribute.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentAttributeOrBuilder>(
+                  attribute_,
+                  ((bitField0_ & 0x00000008) == 0x00000008),
                   getParentForChildren(),
                   isClean());
-          nodeType_ = null;
+          attribute_ = null;
         }
-        return nodeTypeBuilder_;
+        return attributeBuilder_;
       }
 
-      // repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;
+      // repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;
       private java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute> attributes_ =
         java.util.Collections.emptyList();
       private void ensureAttributesIsMutable() {
-        if (!((bitField0_ & 0x00000008) == 0x00000008)) {
+        if (!((bitField0_ & 0x00000010) == 0x00000010)) {
           attributes_ = new java.util.ArrayList<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute>(attributes_);
-          bitField0_ |= 0x00000008;
+          bitField0_ |= 0x00000010;
          }
       }
 
@@ -2302,7 +3807,11 @@ public final class NormalizedNodeMessages {
           org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder> attributesBuilder_;
 
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute> getAttributesList() {
         if (attributesBuilder_ == null) {
@@ -2312,7 +3821,11 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public int getAttributesCount() {
         if (attributesBuilder_ == null) {
@@ -2322,7 +3835,11 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute getAttributes(int index) {
         if (attributesBuilder_ == null) {
@@ -2332,7 +3849,11 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public Builder setAttributes(
           int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute value) {
@@ -2349,7 +3870,11 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public Builder setAttributes(
           int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder builderForValue) {
@@ -2363,7 +3888,11 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public Builder addAttributes(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute value) {
         if (attributesBuilder_ == null) {
@@ -2379,7 +3908,11 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public Builder addAttributes(
           int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute value) {
@@ -2396,7 +3929,11 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public Builder addAttributes(
           org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder builderForValue) {
@@ -2410,7 +3947,11 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public Builder addAttributes(
           int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder builderForValue) {
@@ -2424,7 +3965,11 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public Builder addAllAttributes(
           java.lang.Iterable<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute> values) {
@@ -2438,12 +3983,16 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public Builder clearAttributes() {
         if (attributesBuilder_ == null) {
           attributes_ = java.util.Collections.emptyList();
-          bitField0_ = (bitField0_ & ~0x00000008);
+          bitField0_ = (bitField0_ & ~0x00000010);
           onChanged();
         } else {
           attributesBuilder_.clear();
@@ -2451,7 +4000,11 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public Builder removeAttributes(int index) {
         if (attributesBuilder_ == null) {
@@ -2464,14 +4017,22 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder getAttributesBuilder(
           int index) {
         return getAttributesFieldBuilder().getBuilder(index);
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder getAttributesOrBuilder(
           int index) {
@@ -2481,7 +4042,11 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public java.util.List<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder>
            getAttributesOrBuilderList() {
@@ -2492,14 +4057,22 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder addAttributesBuilder() {
         return getAttributesFieldBuilder().addBuilder(
             org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.getDefaultInstance());
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder addAttributesBuilder(
           int index) {
@@ -2507,7 +4080,11 @@ public final class NormalizedNodeMessages {
             index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.getDefaultInstance());
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
+       *
+       * <pre>
+       * @deprecated For backward compatibility (see InstanceIdentifierUtils)
+       * </pre>
        */
       public java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder>
            getAttributesBuilderList() {
@@ -2520,7 +4097,7 @@ public final class NormalizedNodeMessages {
           attributesBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
               org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder>(
                   attributes_,
-                  ((bitField0_ & 0x00000008) == 0x00000008),
+                  ((bitField0_ & 0x00000010) == 0x00000010),
                   getParentForChildren(),
                   isClean());
           attributes_ = null;
@@ -2528,6 +4105,39 @@ public final class NormalizedNodeMessages {
         return attributesBuilder_;
       }
 
+      // optional int32 intType = 6;
+      private int intType_ ;
+      /**
+       * <code>optional int32 intType = 6;</code>
+       */
+      public boolean hasIntType() {
+        return ((bitField0_ & 0x00000020) == 0x00000020);
+      }
+      /**
+       * <code>optional int32 intType = 6;</code>
+       */
+      public int getIntType() {
+        return intType_;
+      }
+      /**
+       * <code>optional int32 intType = 6;</code>
+       */
+      public Builder setIntType(int value) {
+        bitField0_ |= 0x00000020;
+        intType_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional int32 intType = 6;</code>
+       */
+      public Builder clearIntType() {
+        bitField0_ = (bitField0_ & ~0x00000020);
+        intType_ = 0;
+        onChanged();
+        return this;
+      }
+
       // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.PathArgument)
     }
 
@@ -3231,14 +4841,26 @@ public final class NormalizedNodeMessages {
     // optional string path = 1;
     /**
      * <code>optional string path = 1;</code>
+     *
+     * <pre>
+     * @deprecated(use pathArgument)
+     * </pre>
      */
     boolean hasPath();
     /**
      * <code>optional string path = 1;</code>
+     *
+     * <pre>
+     * @deprecated(use pathArgument)
+     * </pre>
      */
     java.lang.String getPath();
     /**
      * <code>optional string path = 1;</code>
+     *
+     * <pre>
+     * @deprecated(use pathArgument)
+     * </pre>
      */
     com.google.protobuf.ByteString
         getPathBytes();
@@ -3246,131 +4868,261 @@ public final class NormalizedNodeMessages {
     // optional string type = 2;
     /**
      * <code>optional string type = 2;</code>
+     *
+     * <pre>
+     * @deprecated(use intType)
+     * </pre>
      */
     boolean hasType();
     /**
      * <code>optional string type = 2;</code>
+     *
+     * <pre>
+     * @deprecated(use intType)
+     * </pre>
      */
     java.lang.String getType();
     /**
      * <code>optional string type = 2;</code>
+     *
+     * <pre>
+     * @deprecated(use intType)
+     * </pre>
      */
     com.google.protobuf.ByteString
         getTypeBytes();
 
-    // repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;
+    // optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;</code>
+     */
+    boolean hasPathArgument();
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;</code>
+     */
+    org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument getPathArgument();
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;</code>
+     */
+    org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentOrBuilder getPathArgumentOrBuilder();
+
+    // optional int32 intType = 4;
+    /**
+     * <code>optional int32 intType = 4;</code>
+     */
+    boolean hasIntType();
+    /**
+     * <code>optional int32 intType = 4;</code>
+     */
+    int getIntType();
+
+    // repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
      */
     java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute>
         getAttributesList();
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
      */
     org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute getAttributes(int index);
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
      */
     int getAttributesCount();
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
      */
     java.util.List<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder>
         getAttributesOrBuilderList();
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
      */
     org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder getAttributesOrBuilder(
         int index);
 
-    // repeated .org.opendaylight.controller.mdsal.Node child = 4;
+    // repeated .org.opendaylight.controller.mdsal.Node child = 6;
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
      */
     java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node>
         getChildList();
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
      */
     org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node getChild(int index);
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
      */
     int getChildCount();
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
      */
     java.util.List<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.NodeOrBuilder>
         getChildOrBuilderList();
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
      */
     org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.NodeOrBuilder getChildOrBuilder(
         int index);
 
-    // optional string value = 5;
+    // optional string value = 7;
     /**
-     * <code>optional string value = 5;</code>
+     * <code>optional string value = 7;</code>
      */
     boolean hasValue();
     /**
-     * <code>optional string value = 5;</code>
+     * <code>optional string value = 7;</code>
      */
     java.lang.String getValue();
     /**
-     * <code>optional string value = 5;</code>
+     * <code>optional string value = 7;</code>
      */
     com.google.protobuf.ByteString
         getValueBytes();
 
-    // optional string valueType = 6;
+    // optional string valueType = 8;
     /**
-     * <code>optional string valueType = 6;</code>
+     * <code>optional string valueType = 8;</code>
+     *
+     * <pre>
+     * @deprecated(use intValueType)
+     * </pre>
      */
     boolean hasValueType();
     /**
-     * <code>optional string valueType = 6;</code>
+     * <code>optional string valueType = 8;</code>
+     *
+     * <pre>
+     * @deprecated(use intValueType)
+     * </pre>
      */
     java.lang.String getValueType();
     /**
-     * <code>optional string valueType = 6;</code>
+     * <code>optional string valueType = 8;</code>
+     *
+     * <pre>
+     * @deprecated(use intValueType)
+     * </pre>
      */
     com.google.protobuf.ByteString
         getValueTypeBytes();
 
-    // repeated string bitsValue = 7;
+    // optional int32 intValueType = 9;
+    /**
+     * <code>optional int32 intValueType = 9;</code>
+     *
+     * <pre>
+     * instead of valueType
+     * </pre>
+     */
+    boolean hasIntValueType();
+    /**
+     * <code>optional int32 intValueType = 9;</code>
+     *
+     * <pre>
+     * instead of valueType
+     * </pre>
+     */
+    int getIntValueType();
+
+    // optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;</code>
+     *
+     * <pre>
+     * Specific values
+     * </pre>
+     */
+    boolean hasInstanceIdentifierValue();
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;</code>
+     *
+     * <pre>
+     * Specific values
+     * </pre>
+     */
+    org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier getInstanceIdentifierValue();
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;</code>
+     *
+     * <pre>
+     * Specific values
+     * </pre>
+     */
+    org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder getInstanceIdentifierValueOrBuilder();
+
+    // repeated string bitsValue = 11;
     /**
-     * <code>repeated string bitsValue = 7;</code>
+     * <code>repeated string bitsValue = 11;</code>
+     *
+     * <pre>
+     * intValueType = Bits
+     * </pre>
      */
     java.util.List<java.lang.String>
     getBitsValueList();
     /**
-     * <code>repeated string bitsValue = 7;</code>
+     * <code>repeated string bitsValue = 11;</code>
+     *
+     * <pre>
+     * intValueType = Bits
+     * </pre>
      */
     int getBitsValueCount();
     /**
-     * <code>repeated string bitsValue = 7;</code>
+     * <code>repeated string bitsValue = 11;</code>
+     *
+     * <pre>
+     * intValueType = Bits
+     * </pre>
      */
     java.lang.String getBitsValue(int index);
     /**
-     * <code>repeated string bitsValue = 7;</code>
+     * <code>repeated string bitsValue = 11;</code>
+     *
+     * <pre>
+     * intValueType = Bits
+     * </pre>
      */
     com.google.protobuf.ByteString
         getBitsValueBytes(int index);
 
-    // optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;
+    // repeated string code = 12;
     /**
-     * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;</code>
+     * <code>repeated string code = 12;</code>
+     *
+     * <pre>
+     * A list of string codes which can be used for any repeated strings in the NormalizedNode
+     * </pre>
      */
-    boolean hasInstanceIdentifierValue();
+    java.util.List<java.lang.String>
+    getCodeList();
     /**
-     * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;</code>
+     * <code>repeated string code = 12;</code>
+     *
+     * <pre>
+     * A list of string codes which can be used for any repeated strings in the NormalizedNode
+     * </pre>
      */
-    org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier getInstanceIdentifierValue();
+    int getCodeCount();
     /**
-     * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;</code>
+     * <code>repeated string code = 12;</code>
+     *
+     * <pre>
+     * A list of string codes which can be used for any repeated strings in the NormalizedNode
+     * </pre>
      */
-    org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder getInstanceIdentifierValueOrBuilder();
+    java.lang.String getCode(int index);
+    /**
+     * <code>repeated string code = 12;</code>
+     *
+     * <pre>
+     * A list of string codes which can be used for any repeated strings in the NormalizedNode
+     * </pre>
+     */
+    com.google.protobuf.ByteString
+        getCodeBytes(int index);
   }
   /**
    * Protobuf type {@code org.opendaylight.controller.mdsal.Node}
@@ -3434,42 +5186,57 @@ public final class NormalizedNodeMessages {
               break;
             }
             case 26: {
-              if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000004) == 0x00000004)) {
+                subBuilder = pathArgument_.toBuilder();
+              }
+              pathArgument_ = input.readMessage(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(pathArgument_);
+                pathArgument_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000004;
+              break;
+            }
+            case 32: {
+              bitField0_ |= 0x00000008;
+              intType_ = input.readInt32();
+              break;
+            }
+            case 42: {
+              if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
                 attributes_ = new java.util.ArrayList<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute>();
-                mutable_bitField0_ |= 0x00000004;
+                mutable_bitField0_ |= 0x00000010;
               }
               attributes_.add(input.readMessage(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.PARSER, extensionRegistry));
               break;
             }
-            case 34: {
-              if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
+            case 50: {
+              if (!((mutable_bitField0_ & 0x00000020) == 0x00000020)) {
                 child_ = new java.util.ArrayList<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node>();
-                mutable_bitField0_ |= 0x00000008;
+                mutable_bitField0_ |= 0x00000020;
               }
               child_.add(input.readMessage(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node.PARSER, extensionRegistry));
               break;
             }
-            case 42: {
-              bitField0_ |= 0x00000004;
+            case 58: {
+              bitField0_ |= 0x00000010;
               value_ = input.readBytes();
               break;
             }
-            case 50: {
-              bitField0_ |= 0x00000008;
+            case 66: {
+              bitField0_ |= 0x00000020;
               valueType_ = input.readBytes();
               break;
             }
-            case 58: {
-              if (!((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
-                bitsValue_ = new com.google.protobuf.LazyStringArrayList();
-                mutable_bitField0_ |= 0x00000040;
-              }
-              bitsValue_.add(input.readBytes());
+            case 72: {
+              bitField0_ |= 0x00000040;
+              intValueType_ = input.readInt32();
               break;
             }
-            case 66: {
+            case 82: {
               org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder subBuilder = null;
-              if (((bitField0_ & 0x00000010) == 0x00000010)) {
+              if (((bitField0_ & 0x00000080) == 0x00000080)) {
                 subBuilder = instanceIdentifierValue_.toBuilder();
               }
               instanceIdentifierValue_ = input.readMessage(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.PARSER, extensionRegistry);
@@ -3477,7 +5244,23 @@ public final class NormalizedNodeMessages {
                 subBuilder.mergeFrom(instanceIdentifierValue_);
                 instanceIdentifierValue_ = subBuilder.buildPartial();
               }
-              bitField0_ |= 0x00000010;
+              bitField0_ |= 0x00000080;
+              break;
+            }
+            case 90: {
+              if (!((mutable_bitField0_ & 0x00000400) == 0x00000400)) {
+                bitsValue_ = new com.google.protobuf.LazyStringArrayList();
+                mutable_bitField0_ |= 0x00000400;
+              }
+              bitsValue_.add(input.readBytes());
+              break;
+            }
+            case 98: {
+              if (!((mutable_bitField0_ & 0x00000800) == 0x00000800)) {
+                code_ = new com.google.protobuf.LazyStringArrayList();
+                mutable_bitField0_ |= 0x00000800;
+              }
+              code_.add(input.readBytes());
               break;
             }
           }
@@ -3488,15 +5271,18 @@ public final class NormalizedNodeMessages {
         throw new com.google.protobuf.InvalidProtocolBufferException(
             e.getMessage()).setUnfinishedMessage(this);
       } finally {
-        if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+        if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
           attributes_ = java.util.Collections.unmodifiableList(attributes_);
         }
-        if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
+        if (((mutable_bitField0_ & 0x00000020) == 0x00000020)) {
           child_ = java.util.Collections.unmodifiableList(child_);
         }
-        if (((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
+        if (((mutable_bitField0_ & 0x00000400) == 0x00000400)) {
           bitsValue_ = new com.google.protobuf.UnmodifiableLazyStringList(bitsValue_);
         }
+        if (((mutable_bitField0_ & 0x00000800) == 0x00000800)) {
+          code_ = new com.google.protobuf.UnmodifiableLazyStringList(code_);
+        }
         this.unknownFields = unknownFields.build();
         makeExtensionsImmutable();
       }
@@ -3534,12 +5320,20 @@ public final class NormalizedNodeMessages {
     private java.lang.Object path_;
     /**
      * <code>optional string path = 1;</code>
+     *
+     * <pre>
+     * @deprecated(use pathArgument)
+     * </pre>
      */
     public boolean hasPath() {
       return ((bitField0_ & 0x00000001) == 0x00000001);
     }
     /**
      * <code>optional string path = 1;</code>
+     *
+     * <pre>
+     * @deprecated(use pathArgument)
+     * </pre>
      */
     public java.lang.String getPath() {
       java.lang.Object ref = path_;
@@ -3557,6 +5351,10 @@ public final class NormalizedNodeMessages {
     }
     /**
      * <code>optional string path = 1;</code>
+     *
+     * <pre>
+     * @deprecated(use pathArgument)
+     * </pre>
      */
     public com.google.protobuf.ByteString
         getPathBytes() {
@@ -3577,12 +5375,20 @@ public final class NormalizedNodeMessages {
     private java.lang.Object type_;
     /**
      * <code>optional string type = 2;</code>
+     *
+     * <pre>
+     * @deprecated(use intType)
+     * </pre>
      */
     public boolean hasType() {
       return ((bitField0_ & 0x00000002) == 0x00000002);
     }
     /**
      * <code>optional string type = 2;</code>
+     *
+     * <pre>
+     * @deprecated(use intType)
+     * </pre>
      */
     public java.lang.String getType() {
       java.lang.Object ref = type_;
@@ -3600,6 +5406,10 @@ public final class NormalizedNodeMessages {
     }
     /**
      * <code>optional string type = 2;</code>
+     *
+     * <pre>
+     * @deprecated(use intType)
+     * </pre>
      */
     public com.google.protobuf.ByteString
         getTypeBytes() {
@@ -3615,89 +5425,127 @@ public final class NormalizedNodeMessages {
       }
     }
 
-    // repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;
-    public static final int ATTRIBUTES_FIELD_NUMBER = 3;
+    // optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;
+    public static final int PATHARGUMENT_FIELD_NUMBER = 3;
+    private org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument pathArgument_;
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;</code>
+     */
+    public boolean hasPathArgument() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;</code>
+     */
+    public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument getPathArgument() {
+      return pathArgument_;
+    }
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;</code>
+     */
+    public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentOrBuilder getPathArgumentOrBuilder() {
+      return pathArgument_;
+    }
+
+    // optional int32 intType = 4;
+    public static final int INTTYPE_FIELD_NUMBER = 4;
+    private int intType_;
+    /**
+     * <code>optional int32 intType = 4;</code>
+     */
+    public boolean hasIntType() {
+      return ((bitField0_ & 0x00000008) == 0x00000008);
+    }
+    /**
+     * <code>optional int32 intType = 4;</code>
+     */
+    public int getIntType() {
+      return intType_;
+    }
+
+    // repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;
+    public static final int ATTRIBUTES_FIELD_NUMBER = 5;
     private java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute> attributes_;
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
      */
     public java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute> getAttributesList() {
       return attributes_;
     }
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
      */
     public java.util.List<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder>
         getAttributesOrBuilderList() {
       return attributes_;
     }
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
      */
     public int getAttributesCount() {
       return attributes_.size();
     }
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
      */
     public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute getAttributes(int index) {
       return attributes_.get(index);
     }
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
      */
     public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder getAttributesOrBuilder(
         int index) {
       return attributes_.get(index);
     }
 
-    // repeated .org.opendaylight.controller.mdsal.Node child = 4;
-    public static final int CHILD_FIELD_NUMBER = 4;
+    // repeated .org.opendaylight.controller.mdsal.Node child = 6;
+    public static final int CHILD_FIELD_NUMBER = 6;
     private java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node> child_;
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
      */
     public java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node> getChildList() {
       return child_;
     }
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
      */
     public java.util.List<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.NodeOrBuilder>
         getChildOrBuilderList() {
       return child_;
     }
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
      */
     public int getChildCount() {
       return child_.size();
     }
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
      */
     public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node getChild(int index) {
       return child_.get(index);
     }
     /**
-     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+     * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
      */
     public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.NodeOrBuilder getChildOrBuilder(
         int index) {
       return child_.get(index);
     }
 
-    // optional string value = 5;
-    public static final int VALUE_FIELD_NUMBER = 5;
+    // optional string value = 7;
+    public static final int VALUE_FIELD_NUMBER = 7;
     private java.lang.Object value_;
     /**
-     * <code>optional string value = 5;</code>
+     * <code>optional string value = 7;</code>
      */
     public boolean hasValue() {
-      return ((bitField0_ & 0x00000004) == 0x00000004);
+      return ((bitField0_ & 0x00000010) == 0x00000010);
     }
     /**
-     * <code>optional string value = 5;</code>
+     * <code>optional string value = 7;</code>
      */
     public java.lang.String getValue() {
       java.lang.Object ref = value_;
@@ -3714,7 +5562,7 @@ public final class NormalizedNodeMessages {
       }
     }
     /**
-     * <code>optional string value = 5;</code>
+     * <code>optional string value = 7;</code>
      */
     public com.google.protobuf.ByteString
         getValueBytes() {
@@ -3730,17 +5578,25 @@ public final class NormalizedNodeMessages {
       }
     }
 
-    // optional string valueType = 6;
-    public static final int VALUETYPE_FIELD_NUMBER = 6;
+    // optional string valueType = 8;
+    public static final int VALUETYPE_FIELD_NUMBER = 8;
     private java.lang.Object valueType_;
     /**
-     * <code>optional string valueType = 6;</code>
+     * <code>optional string valueType = 8;</code>
+     *
+     * <pre>
+     * @deprecated(use intValueType)
+     * </pre>
      */
     public boolean hasValueType() {
-      return ((bitField0_ & 0x00000008) == 0x00000008);
+      return ((bitField0_ & 0x00000020) == 0x00000020);
     }
     /**
-     * <code>optional string valueType = 6;</code>
+     * <code>optional string valueType = 8;</code>
+     *
+     * <pre>
+     * @deprecated(use intValueType)
+     * </pre>
      */
     public java.lang.String getValueType() {
       java.lang.Object ref = valueType_;
@@ -3757,7 +5613,11 @@ public final class NormalizedNodeMessages {
       }
     }
     /**
-     * <code>optional string valueType = 6;</code>
+     * <code>optional string valueType = 8;</code>
+     *
+     * <pre>
+     * @deprecated(use intValueType)
+     * </pre>
      */
     public com.google.protobuf.ByteString
         getValueTypeBytes() {
@@ -3773,73 +5633,181 @@ public final class NormalizedNodeMessages {
       }
     }
 
-    // repeated string bitsValue = 7;
-    public static final int BITSVALUE_FIELD_NUMBER = 7;
+    // optional int32 intValueType = 9;
+    public static final int INTVALUETYPE_FIELD_NUMBER = 9;
+    private int intValueType_;
+    /**
+     * <code>optional int32 intValueType = 9;</code>
+     *
+     * <pre>
+     * instead of valueType
+     * </pre>
+     */
+    public boolean hasIntValueType() {
+      return ((bitField0_ & 0x00000040) == 0x00000040);
+    }
+    /**
+     * <code>optional int32 intValueType = 9;</code>
+     *
+     * <pre>
+     * instead of valueType
+     * </pre>
+     */
+    public int getIntValueType() {
+      return intValueType_;
+    }
+
+    // optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;
+    public static final int INSTANCEIDENTIFIERVALUE_FIELD_NUMBER = 10;
+    private org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier instanceIdentifierValue_;
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;</code>
+     *
+     * <pre>
+     * Specific values
+     * </pre>
+     */
+    public boolean hasInstanceIdentifierValue() {
+      return ((bitField0_ & 0x00000080) == 0x00000080);
+    }
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;</code>
+     *
+     * <pre>
+     * Specific values
+     * </pre>
+     */
+    public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier getInstanceIdentifierValue() {
+      return instanceIdentifierValue_;
+    }
+    /**
+     * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;</code>
+     *
+     * <pre>
+     * Specific values
+     * </pre>
+     */
+    public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder getInstanceIdentifierValueOrBuilder() {
+      return instanceIdentifierValue_;
+    }
+
+    // repeated string bitsValue = 11;
+    public static final int BITSVALUE_FIELD_NUMBER = 11;
     private com.google.protobuf.LazyStringList bitsValue_;
     /**
-     * <code>repeated string bitsValue = 7;</code>
+     * <code>repeated string bitsValue = 11;</code>
+     *
+     * <pre>
+     * intValueType = Bits
+     * </pre>
      */
     public java.util.List<java.lang.String>
         getBitsValueList() {
       return bitsValue_;
     }
     /**
-     * <code>repeated string bitsValue = 7;</code>
+     * <code>repeated string bitsValue = 11;</code>
+     *
+     * <pre>
+     * intValueType = Bits
+     * </pre>
      */
     public int getBitsValueCount() {
       return bitsValue_.size();
     }
     /**
-     * <code>repeated string bitsValue = 7;</code>
+     * <code>repeated string bitsValue = 11;</code>
+     *
+     * <pre>
+     * intValueType = Bits
+     * </pre>
      */
     public java.lang.String getBitsValue(int index) {
       return bitsValue_.get(index);
     }
     /**
-     * <code>repeated string bitsValue = 7;</code>
+     * <code>repeated string bitsValue = 11;</code>
+     *
+     * <pre>
+     * intValueType = Bits
+     * </pre>
      */
     public com.google.protobuf.ByteString
         getBitsValueBytes(int index) {
       return bitsValue_.getByteString(index);
     }
 
-    // optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;
-    public static final int INSTANCEIDENTIFIERVALUE_FIELD_NUMBER = 8;
-    private org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier instanceIdentifierValue_;
+    // repeated string code = 12;
+    public static final int CODE_FIELD_NUMBER = 12;
+    private com.google.protobuf.LazyStringList code_;
     /**
-     * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;</code>
+     * <code>repeated string code = 12;</code>
+     *
+     * <pre>
+     * A list of string codes which can be used for any repeated strings in the NormalizedNode
+     * </pre>
      */
-    public boolean hasInstanceIdentifierValue() {
-      return ((bitField0_ & 0x00000010) == 0x00000010);
+    public java.util.List<java.lang.String>
+        getCodeList() {
+      return code_;
+    }
+    /**
+     * <code>repeated string code = 12;</code>
+     *
+     * <pre>
+     * A list of string codes which can be used for any repeated strings in the NormalizedNode
+     * </pre>
+     */
+    public int getCodeCount() {
+      return code_.size();
     }
     /**
-     * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;</code>
+     * <code>repeated string code = 12;</code>
+     *
+     * <pre>
+     * A list of string codes which can be used for any repeated strings in the NormalizedNode
+     * </pre>
      */
-    public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier getInstanceIdentifierValue() {
-      return instanceIdentifierValue_;
+    public java.lang.String getCode(int index) {
+      return code_.get(index);
     }
     /**
-     * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;</code>
+     * <code>repeated string code = 12;</code>
+     *
+     * <pre>
+     * A list of string codes which can be used for any repeated strings in the NormalizedNode
+     * </pre>
      */
-    public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder getInstanceIdentifierValueOrBuilder() {
-      return instanceIdentifierValue_;
+    public com.google.protobuf.ByteString
+        getCodeBytes(int index) {
+      return code_.getByteString(index);
     }
 
     private void initFields() {
       path_ = "";
       type_ = "";
+      pathArgument_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument.getDefaultInstance();
+      intType_ = 0;
       attributes_ = java.util.Collections.emptyList();
       child_ = java.util.Collections.emptyList();
       value_ = "";
       valueType_ = "";
-      bitsValue_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+      intValueType_ = 0;
       instanceIdentifierValue_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.getDefaultInstance();
+      bitsValue_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+      code_ = com.google.protobuf.LazyStringArrayList.EMPTY;
     }
     private byte memoizedIsInitialized = -1;
     public final boolean isInitialized() {
       byte isInitialized = memoizedIsInitialized;
       if (isInitialized != -1) return isInitialized == 1;
 
+      if (hasPathArgument()) {
+        if (!getPathArgument().isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
       for (int i = 0; i < getAttributesCount(); i++) {
         if (!getAttributes(i).isInitialized()) {
           memoizedIsInitialized = 0;
@@ -3871,23 +5839,35 @@ public final class NormalizedNodeMessages {
       if (((bitField0_ & 0x00000002) == 0x00000002)) {
         output.writeBytes(2, getTypeBytes());
       }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        output.writeMessage(3, pathArgument_);
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        output.writeInt32(4, intType_);
+      }
       for (int i = 0; i < attributes_.size(); i++) {
-        output.writeMessage(3, attributes_.get(i));
+        output.writeMessage(5, attributes_.get(i));
       }
       for (int i = 0; i < child_.size(); i++) {
-        output.writeMessage(4, child_.get(i));
+        output.writeMessage(6, child_.get(i));
       }
-      if (((bitField0_ & 0x00000004) == 0x00000004)) {
-        output.writeBytes(5, getValueBytes());
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
+        output.writeBytes(7, getValueBytes());
       }
-      if (((bitField0_ & 0x00000008) == 0x00000008)) {
-        output.writeBytes(6, getValueTypeBytes());
+      if (((bitField0_ & 0x00000020) == 0x00000020)) {
+        output.writeBytes(8, getValueTypeBytes());
+      }
+      if (((bitField0_ & 0x00000040) == 0x00000040)) {
+        output.writeInt32(9, intValueType_);
+      }
+      if (((bitField0_ & 0x00000080) == 0x00000080)) {
+        output.writeMessage(10, instanceIdentifierValue_);
       }
       for (int i = 0; i < bitsValue_.size(); i++) {
-        output.writeBytes(7, bitsValue_.getByteString(i));
+        output.writeBytes(11, bitsValue_.getByteString(i));
       }
-      if (((bitField0_ & 0x00000010) == 0x00000010)) {
-        output.writeMessage(8, instanceIdentifierValue_);
+      for (int i = 0; i < code_.size(); i++) {
+        output.writeBytes(12, code_.getByteString(i));
       }
       getUnknownFields().writeTo(output);
     }
@@ -3906,21 +5886,37 @@ public final class NormalizedNodeMessages {
         size += com.google.protobuf.CodedOutputStream
           .computeBytesSize(2, getTypeBytes());
       }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(3, pathArgument_);
+      }
+      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(4, intType_);
+      }
       for (int i = 0; i < attributes_.size(); i++) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(3, attributes_.get(i));
+          .computeMessageSize(5, attributes_.get(i));
       }
       for (int i = 0; i < child_.size(); i++) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(4, child_.get(i));
+          .computeMessageSize(6, child_.get(i));
       }
-      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
         size += com.google.protobuf.CodedOutputStream
-          .computeBytesSize(5, getValueBytes());
+          .computeBytesSize(7, getValueBytes());
       }
-      if (((bitField0_ & 0x00000008) == 0x00000008)) {
+      if (((bitField0_ & 0x00000020) == 0x00000020)) {
         size += com.google.protobuf.CodedOutputStream
-          .computeBytesSize(6, getValueTypeBytes());
+          .computeBytesSize(8, getValueTypeBytes());
+      }
+      if (((bitField0_ & 0x00000040) == 0x00000040)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(9, intValueType_);
+      }
+      if (((bitField0_ & 0x00000080) == 0x00000080)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(10, instanceIdentifierValue_);
       }
       {
         int dataSize = 0;
@@ -3931,9 +5927,14 @@ public final class NormalizedNodeMessages {
         size += dataSize;
         size += 1 * getBitsValueList().size();
       }
-      if (((bitField0_ & 0x00000010) == 0x00000010)) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(8, instanceIdentifierValue_);
+      {
+        int dataSize = 0;
+        for (int i = 0; i < code_.size(); i++) {
+          dataSize += com.google.protobuf.CodedOutputStream
+            .computeBytesSizeNoTag(code_.getByteString(i));
+        }
+        size += dataSize;
+        size += 1 * getCodeList().size();
       }
       size += getUnknownFields().getSerializedSize();
       memoizedSerializedSize = size;
@@ -4043,6 +6044,7 @@ public final class NormalizedNodeMessages {
       }
       private void maybeForceBuilderInitialization() {
         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+          getPathArgumentFieldBuilder();
           getAttributesFieldBuilder();
           getChildFieldBuilder();
           getInstanceIdentifierValueFieldBuilder();
@@ -4058,30 +6060,42 @@ public final class NormalizedNodeMessages {
         bitField0_ = (bitField0_ & ~0x00000001);
         type_ = "";
         bitField0_ = (bitField0_ & ~0x00000002);
+        if (pathArgumentBuilder_ == null) {
+          pathArgument_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument.getDefaultInstance();
+        } else {
+          pathArgumentBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000004);
+        intType_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000008);
         if (attributesBuilder_ == null) {
           attributes_ = java.util.Collections.emptyList();
-          bitField0_ = (bitField0_ & ~0x00000004);
+          bitField0_ = (bitField0_ & ~0x00000010);
         } else {
           attributesBuilder_.clear();
         }
         if (childBuilder_ == null) {
           child_ = java.util.Collections.emptyList();
-          bitField0_ = (bitField0_ & ~0x00000008);
+          bitField0_ = (bitField0_ & ~0x00000020);
         } else {
           childBuilder_.clear();
         }
         value_ = "";
-        bitField0_ = (bitField0_ & ~0x00000010);
-        valueType_ = "";
-        bitField0_ = (bitField0_ & ~0x00000020);
-        bitsValue_ = com.google.protobuf.LazyStringArrayList.EMPTY;
         bitField0_ = (bitField0_ & ~0x00000040);
+        valueType_ = "";
+        bitField0_ = (bitField0_ & ~0x00000080);
+        intValueType_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000100);
         if (instanceIdentifierValueBuilder_ == null) {
           instanceIdentifierValue_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.getDefaultInstance();
         } else {
           instanceIdentifierValueBuilder_.clear();
         }
-        bitField0_ = (bitField0_ & ~0x00000080);
+        bitField0_ = (bitField0_ & ~0x00000200);
+        bitsValue_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+        bitField0_ = (bitField0_ & ~0x00000400);
+        code_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+        bitField0_ = (bitField0_ & ~0x00000800);
         return this;
       }
 
@@ -4118,46 +6132,68 @@ public final class NormalizedNodeMessages {
           to_bitField0_ |= 0x00000002;
         }
         result.type_ = type_;
+        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+          to_bitField0_ |= 0x00000004;
+        }
+        if (pathArgumentBuilder_ == null) {
+          result.pathArgument_ = pathArgument_;
+        } else {
+          result.pathArgument_ = pathArgumentBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+          to_bitField0_ |= 0x00000008;
+        }
+        result.intType_ = intType_;
         if (attributesBuilder_ == null) {
-          if (((bitField0_ & 0x00000004) == 0x00000004)) {
+          if (((bitField0_ & 0x00000010) == 0x00000010)) {
             attributes_ = java.util.Collections.unmodifiableList(attributes_);
-            bitField0_ = (bitField0_ & ~0x00000004);
+            bitField0_ = (bitField0_ & ~0x00000010);
           }
           result.attributes_ = attributes_;
         } else {
           result.attributes_ = attributesBuilder_.build();
         }
         if (childBuilder_ == null) {
-          if (((bitField0_ & 0x00000008) == 0x00000008)) {
+          if (((bitField0_ & 0x00000020) == 0x00000020)) {
             child_ = java.util.Collections.unmodifiableList(child_);
-            bitField0_ = (bitField0_ & ~0x00000008);
+            bitField0_ = (bitField0_ & ~0x00000020);
           }
           result.child_ = child_;
         } else {
           result.child_ = childBuilder_.build();
         }
-        if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
-          to_bitField0_ |= 0x00000004;
+        if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
+          to_bitField0_ |= 0x00000010;
         }
         result.value_ = value_;
-        if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
-          to_bitField0_ |= 0x00000008;
+        if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
+          to_bitField0_ |= 0x00000020;
         }
         result.valueType_ = valueType_;
-        if (((bitField0_ & 0x00000040) == 0x00000040)) {
-          bitsValue_ = new com.google.protobuf.UnmodifiableLazyStringList(
-              bitsValue_);
-          bitField0_ = (bitField0_ & ~0x00000040);
+        if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
+          to_bitField0_ |= 0x00000040;
         }
-        result.bitsValue_ = bitsValue_;
-        if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
-          to_bitField0_ |= 0x00000010;
+        result.intValueType_ = intValueType_;
+        if (((from_bitField0_ & 0x00000200) == 0x00000200)) {
+          to_bitField0_ |= 0x00000080;
         }
         if (instanceIdentifierValueBuilder_ == null) {
           result.instanceIdentifierValue_ = instanceIdentifierValue_;
         } else {
           result.instanceIdentifierValue_ = instanceIdentifierValueBuilder_.build();
         }
+        if (((bitField0_ & 0x00000400) == 0x00000400)) {
+          bitsValue_ = new com.google.protobuf.UnmodifiableLazyStringList(
+              bitsValue_);
+          bitField0_ = (bitField0_ & ~0x00000400);
+        }
+        result.bitsValue_ = bitsValue_;
+        if (((bitField0_ & 0x00000800) == 0x00000800)) {
+          code_ = new com.google.protobuf.UnmodifiableLazyStringList(
+              code_);
+          bitField0_ = (bitField0_ & ~0x00000800);
+        }
+        result.code_ = code_;
         result.bitField0_ = to_bitField0_;
         onBuilt();
         return result;
@@ -4184,11 +6220,17 @@ public final class NormalizedNodeMessages {
           type_ = other.type_;
           onChanged();
         }
+        if (other.hasPathArgument()) {
+          mergePathArgument(other.getPathArgument());
+        }
+        if (other.hasIntType()) {
+          setIntType(other.getIntType());
+        }
         if (attributesBuilder_ == null) {
           if (!other.attributes_.isEmpty()) {
             if (attributes_.isEmpty()) {
               attributes_ = other.attributes_;
-              bitField0_ = (bitField0_ & ~0x00000004);
+              bitField0_ = (bitField0_ & ~0x00000010);
             } else {
               ensureAttributesIsMutable();
               attributes_.addAll(other.attributes_);
@@ -4201,7 +6243,7 @@ public final class NormalizedNodeMessages {
               attributesBuilder_.dispose();
               attributesBuilder_ = null;
               attributes_ = other.attributes_;
-              bitField0_ = (bitField0_ & ~0x00000004);
+              bitField0_ = (bitField0_ & ~0x00000010);
               attributesBuilder_ =
                 com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
                    getAttributesFieldBuilder() : null;
@@ -4214,7 +6256,7 @@ public final class NormalizedNodeMessages {
           if (!other.child_.isEmpty()) {
             if (child_.isEmpty()) {
               child_ = other.child_;
-              bitField0_ = (bitField0_ & ~0x00000008);
+              bitField0_ = (bitField0_ & ~0x00000020);
             } else {
               ensureChildIsMutable();
               child_.addAll(other.child_);
@@ -4227,7 +6269,7 @@ public final class NormalizedNodeMessages {
               childBuilder_.dispose();
               childBuilder_ = null;
               child_ = other.child_;
-              bitField0_ = (bitField0_ & ~0x00000008);
+              bitField0_ = (bitField0_ & ~0x00000020);
               childBuilder_ =
                 com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
                    getChildFieldBuilder() : null;
@@ -4237,33 +6279,52 @@ public final class NormalizedNodeMessages {
           }
         }
         if (other.hasValue()) {
-          bitField0_ |= 0x00000010;
+          bitField0_ |= 0x00000040;
           value_ = other.value_;
           onChanged();
         }
         if (other.hasValueType()) {
-          bitField0_ |= 0x00000020;
+          bitField0_ |= 0x00000080;
           valueType_ = other.valueType_;
           onChanged();
         }
+        if (other.hasIntValueType()) {
+          setIntValueType(other.getIntValueType());
+        }
+        if (other.hasInstanceIdentifierValue()) {
+          mergeInstanceIdentifierValue(other.getInstanceIdentifierValue());
+        }
         if (!other.bitsValue_.isEmpty()) {
           if (bitsValue_.isEmpty()) {
             bitsValue_ = other.bitsValue_;
-            bitField0_ = (bitField0_ & ~0x00000040);
+            bitField0_ = (bitField0_ & ~0x00000400);
           } else {
             ensureBitsValueIsMutable();
             bitsValue_.addAll(other.bitsValue_);
           }
           onChanged();
         }
-        if (other.hasInstanceIdentifierValue()) {
-          mergeInstanceIdentifierValue(other.getInstanceIdentifierValue());
+        if (!other.code_.isEmpty()) {
+          if (code_.isEmpty()) {
+            code_ = other.code_;
+            bitField0_ = (bitField0_ & ~0x00000800);
+          } else {
+            ensureCodeIsMutable();
+            code_.addAll(other.code_);
+          }
+          onChanged();
         }
         this.mergeUnknownFields(other.getUnknownFields());
         return this;
       }
 
       public final boolean isInitialized() {
+        if (hasPathArgument()) {
+          if (!getPathArgument().isInitialized()) {
+
+            return false;
+          }
+        }
         for (int i = 0; i < getAttributesCount(); i++) {
           if (!getAttributes(i).isInitialized()) {
 
@@ -4308,12 +6369,20 @@ public final class NormalizedNodeMessages {
       private java.lang.Object path_ = "";
       /**
        * <code>optional string path = 1;</code>
+       *
+       * <pre>
+       * @deprecated(use pathArgument)
+       * </pre>
        */
       public boolean hasPath() {
         return ((bitField0_ & 0x00000001) == 0x00000001);
       }
       /**
        * <code>optional string path = 1;</code>
+       *
+       * <pre>
+       * @deprecated(use pathArgument)
+       * </pre>
        */
       public java.lang.String getPath() {
         java.lang.Object ref = path_;
@@ -4328,6 +6397,10 @@ public final class NormalizedNodeMessages {
       }
       /**
        * <code>optional string path = 1;</code>
+       *
+       * <pre>
+       * @deprecated(use pathArgument)
+       * </pre>
        */
       public com.google.protobuf.ByteString
           getPathBytes() {
@@ -4344,6 +6417,10 @@ public final class NormalizedNodeMessages {
       }
       /**
        * <code>optional string path = 1;</code>
+       *
+       * <pre>
+       * @deprecated(use pathArgument)
+       * </pre>
        */
       public Builder setPath(
           java.lang.String value) {
@@ -4357,6 +6434,10 @@ public final class NormalizedNodeMessages {
       }
       /**
        * <code>optional string path = 1;</code>
+       *
+       * <pre>
+       * @deprecated(use pathArgument)
+       * </pre>
        */
       public Builder clearPath() {
         bitField0_ = (bitField0_ & ~0x00000001);
@@ -4366,6 +6447,10 @@ public final class NormalizedNodeMessages {
       }
       /**
        * <code>optional string path = 1;</code>
+       *
+       * <pre>
+       * @deprecated(use pathArgument)
+       * </pre>
        */
       public Builder setPathBytes(
           com.google.protobuf.ByteString value) {
@@ -4382,12 +6467,20 @@ public final class NormalizedNodeMessages {
       private java.lang.Object type_ = "";
       /**
        * <code>optional string type = 2;</code>
+       *
+       * <pre>
+       * @deprecated(use intType)
+       * </pre>
        */
       public boolean hasType() {
         return ((bitField0_ & 0x00000002) == 0x00000002);
       }
       /**
        * <code>optional string type = 2;</code>
+       *
+       * <pre>
+       * @deprecated(use intType)
+       * </pre>
        */
       public java.lang.String getType() {
         java.lang.Object ref = type_;
@@ -4402,6 +6495,10 @@ public final class NormalizedNodeMessages {
       }
       /**
        * <code>optional string type = 2;</code>
+       *
+       * <pre>
+       * @deprecated(use intType)
+       * </pre>
        */
       public com.google.protobuf.ByteString
           getTypeBytes() {
@@ -4418,6 +6515,10 @@ public final class NormalizedNodeMessages {
       }
       /**
        * <code>optional string type = 2;</code>
+       *
+       * <pre>
+       * @deprecated(use intType)
+       * </pre>
        */
       public Builder setType(
           java.lang.String value) {
@@ -4431,6 +6532,10 @@ public final class NormalizedNodeMessages {
       }
       /**
        * <code>optional string type = 2;</code>
+       *
+       * <pre>
+       * @deprecated(use intType)
+       * </pre>
        */
       public Builder clearType() {
         bitField0_ = (bitField0_ & ~0x00000002);
@@ -4440,6 +6545,10 @@ public final class NormalizedNodeMessages {
       }
       /**
        * <code>optional string type = 2;</code>
+       *
+       * <pre>
+       * @deprecated(use intType)
+       * </pre>
        */
       public Builder setTypeBytes(
           com.google.protobuf.ByteString value) {
@@ -4452,13 +6561,163 @@ public final class NormalizedNodeMessages {
         return this;
       }
 
-      // repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;
+      // optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;
+      private org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument pathArgument_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentOrBuilder> pathArgumentBuilder_;
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;</code>
+       */
+      public boolean hasPathArgument() {
+        return ((bitField0_ & 0x00000004) == 0x00000004);
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;</code>
+       */
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument getPathArgument() {
+        if (pathArgumentBuilder_ == null) {
+          return pathArgument_;
+        } else {
+          return pathArgumentBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;</code>
+       */
+      public Builder setPathArgument(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument value) {
+        if (pathArgumentBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          pathArgument_ = value;
+          onChanged();
+        } else {
+          pathArgumentBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000004;
+        return this;
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;</code>
+       */
+      public Builder setPathArgument(
+          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument.Builder builderForValue) {
+        if (pathArgumentBuilder_ == null) {
+          pathArgument_ = builderForValue.build();
+          onChanged();
+        } else {
+          pathArgumentBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000004;
+        return this;
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;</code>
+       */
+      public Builder mergePathArgument(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument value) {
+        if (pathArgumentBuilder_ == null) {
+          if (((bitField0_ & 0x00000004) == 0x00000004) &&
+              pathArgument_ != org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument.getDefaultInstance()) {
+            pathArgument_ =
+              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument.newBuilder(pathArgument_).mergeFrom(value).buildPartial();
+          } else {
+            pathArgument_ = value;
+          }
+          onChanged();
+        } else {
+          pathArgumentBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000004;
+        return this;
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;</code>
+       */
+      public Builder clearPathArgument() {
+        if (pathArgumentBuilder_ == null) {
+          pathArgument_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument.getDefaultInstance();
+          onChanged();
+        } else {
+          pathArgumentBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000004);
+        return this;
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;</code>
+       */
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument.Builder getPathArgumentBuilder() {
+        bitField0_ |= 0x00000004;
+        onChanged();
+        return getPathArgumentFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;</code>
+       */
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentOrBuilder getPathArgumentOrBuilder() {
+        if (pathArgumentBuilder_ != null) {
+          return pathArgumentBuilder_.getMessageOrBuilder();
+        } else {
+          return pathArgument_;
+        }
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.PathArgument pathArgument = 3;</code>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentOrBuilder>
+          getPathArgumentFieldBuilder() {
+        if (pathArgumentBuilder_ == null) {
+          pathArgumentBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgument.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.PathArgumentOrBuilder>(
+                  pathArgument_,
+                  getParentForChildren(),
+                  isClean());
+          pathArgument_ = null;
+        }
+        return pathArgumentBuilder_;
+      }
+
+      // optional int32 intType = 4;
+      private int intType_ ;
+      /**
+       * <code>optional int32 intType = 4;</code>
+       */
+      public boolean hasIntType() {
+        return ((bitField0_ & 0x00000008) == 0x00000008);
+      }
+      /**
+       * <code>optional int32 intType = 4;</code>
+       */
+      public int getIntType() {
+        return intType_;
+      }
+      /**
+       * <code>optional int32 intType = 4;</code>
+       */
+      public Builder setIntType(int value) {
+        bitField0_ |= 0x00000008;
+        intType_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional int32 intType = 4;</code>
+       */
+      public Builder clearIntType() {
+        bitField0_ = (bitField0_ & ~0x00000008);
+        intType_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;
       private java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute> attributes_ =
         java.util.Collections.emptyList();
       private void ensureAttributesIsMutable() {
-        if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+        if (!((bitField0_ & 0x00000010) == 0x00000010)) {
           attributes_ = new java.util.ArrayList<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute>(attributes_);
-          bitField0_ |= 0x00000004;
+          bitField0_ |= 0x00000010;
          }
       }
 
@@ -4466,7 +6725,7 @@ public final class NormalizedNodeMessages {
           org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder> attributesBuilder_;
 
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute> getAttributesList() {
         if (attributesBuilder_ == null) {
@@ -4476,7 +6735,7 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public int getAttributesCount() {
         if (attributesBuilder_ == null) {
@@ -4486,7 +6745,7 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute getAttributes(int index) {
         if (attributesBuilder_ == null) {
@@ -4496,7 +6755,7 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public Builder setAttributes(
           int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute value) {
@@ -4513,7 +6772,7 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public Builder setAttributes(
           int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder builderForValue) {
@@ -4527,7 +6786,7 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public Builder addAttributes(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute value) {
         if (attributesBuilder_ == null) {
@@ -4543,7 +6802,7 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public Builder addAttributes(
           int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute value) {
@@ -4560,7 +6819,7 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public Builder addAttributes(
           org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder builderForValue) {
@@ -4574,7 +6833,7 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public Builder addAttributes(
           int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder builderForValue) {
@@ -4588,7 +6847,7 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public Builder addAllAttributes(
           java.lang.Iterable<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute> values) {
@@ -4602,12 +6861,12 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public Builder clearAttributes() {
         if (attributesBuilder_ == null) {
           attributes_ = java.util.Collections.emptyList();
-          bitField0_ = (bitField0_ & ~0x00000004);
+          bitField0_ = (bitField0_ & ~0x00000010);
           onChanged();
         } else {
           attributesBuilder_.clear();
@@ -4615,7 +6874,7 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public Builder removeAttributes(int index) {
         if (attributesBuilder_ == null) {
@@ -4628,14 +6887,14 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder getAttributesBuilder(
           int index) {
         return getAttributesFieldBuilder().getBuilder(index);
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder getAttributesOrBuilder(
           int index) {
@@ -4645,7 +6904,7 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public java.util.List<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder>
            getAttributesOrBuilderList() {
@@ -4656,14 +6915,14 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder addAttributesBuilder() {
         return getAttributesFieldBuilder().addBuilder(
             org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.getDefaultInstance());
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder addAttributesBuilder(
           int index) {
@@ -4671,7 +6930,7 @@ public final class NormalizedNodeMessages {
             index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.getDefaultInstance());
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 3;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Attribute attributes = 5;</code>
        */
       public java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder>
            getAttributesBuilderList() {
@@ -4684,7 +6943,7 @@ public final class NormalizedNodeMessages {
           attributesBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
               org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Attribute.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.AttributeOrBuilder>(
                   attributes_,
-                  ((bitField0_ & 0x00000004) == 0x00000004),
+                  ((bitField0_ & 0x00000010) == 0x00000010),
                   getParentForChildren(),
                   isClean());
           attributes_ = null;
@@ -4692,13 +6951,13 @@ public final class NormalizedNodeMessages {
         return attributesBuilder_;
       }
 
-      // repeated .org.opendaylight.controller.mdsal.Node child = 4;
+      // repeated .org.opendaylight.controller.mdsal.Node child = 6;
       private java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node> child_ =
         java.util.Collections.emptyList();
       private void ensureChildIsMutable() {
-        if (!((bitField0_ & 0x00000008) == 0x00000008)) {
+        if (!((bitField0_ & 0x00000020) == 0x00000020)) {
           child_ = new java.util.ArrayList<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node>(child_);
-          bitField0_ |= 0x00000008;
+          bitField0_ |= 0x00000020;
          }
       }
 
@@ -4706,7 +6965,7 @@ public final class NormalizedNodeMessages {
           org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.NodeOrBuilder> childBuilder_;
 
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node> getChildList() {
         if (childBuilder_ == null) {
@@ -4716,7 +6975,7 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public int getChildCount() {
         if (childBuilder_ == null) {
@@ -4726,7 +6985,7 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node getChild(int index) {
         if (childBuilder_ == null) {
@@ -4736,7 +6995,7 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public Builder setChild(
           int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node value) {
@@ -4753,7 +7012,7 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public Builder setChild(
           int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node.Builder builderForValue) {
@@ -4767,7 +7026,7 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public Builder addChild(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node value) {
         if (childBuilder_ == null) {
@@ -4783,7 +7042,7 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public Builder addChild(
           int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node value) {
@@ -4800,7 +7059,7 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public Builder addChild(
           org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node.Builder builderForValue) {
@@ -4814,7 +7073,7 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public Builder addChild(
           int index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node.Builder builderForValue) {
@@ -4828,7 +7087,7 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public Builder addAllChild(
           java.lang.Iterable<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node> values) {
@@ -4842,12 +7101,12 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public Builder clearChild() {
         if (childBuilder_ == null) {
           child_ = java.util.Collections.emptyList();
-          bitField0_ = (bitField0_ & ~0x00000008);
+          bitField0_ = (bitField0_ & ~0x00000020);
           onChanged();
         } else {
           childBuilder_.clear();
@@ -4855,7 +7114,7 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public Builder removeChild(int index) {
         if (childBuilder_ == null) {
@@ -4868,14 +7127,14 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node.Builder getChildBuilder(
           int index) {
         return getChildFieldBuilder().getBuilder(index);
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.NodeOrBuilder getChildOrBuilder(
           int index) {
@@ -4885,7 +7144,7 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public java.util.List<? extends org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.NodeOrBuilder>
            getChildOrBuilderList() {
@@ -4896,14 +7155,14 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node.Builder addChildBuilder() {
         return getChildFieldBuilder().addBuilder(
             org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node.getDefaultInstance());
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node.Builder addChildBuilder(
           int index) {
@@ -4911,7 +7170,7 @@ public final class NormalizedNodeMessages {
             index, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node.getDefaultInstance());
       }
       /**
-       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 4;</code>
+       * <code>repeated .org.opendaylight.controller.mdsal.Node child = 6;</code>
        */
       public java.util.List<org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node.Builder>
            getChildBuilderList() {
@@ -4924,7 +7183,7 @@ public final class NormalizedNodeMessages {
           childBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
               org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.NodeOrBuilder>(
                   child_,
-                  ((bitField0_ & 0x00000008) == 0x00000008),
+                  ((bitField0_ & 0x00000020) == 0x00000020),
                   getParentForChildren(),
                   isClean());
           child_ = null;
@@ -4932,16 +7191,16 @@ public final class NormalizedNodeMessages {
         return childBuilder_;
       }
 
-      // optional string value = 5;
+      // optional string value = 7;
       private java.lang.Object value_ = "";
       /**
-       * <code>optional string value = 5;</code>
+       * <code>optional string value = 7;</code>
        */
       public boolean hasValue() {
-        return ((bitField0_ & 0x00000010) == 0x00000010);
+        return ((bitField0_ & 0x00000040) == 0x00000040);
       }
       /**
-       * <code>optional string value = 5;</code>
+       * <code>optional string value = 7;</code>
        */
       public java.lang.String getValue() {
         java.lang.Object ref = value_;
@@ -4955,7 +7214,7 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>optional string value = 5;</code>
+       * <code>optional string value = 7;</code>
        */
       public com.google.protobuf.ByteString
           getValueBytes() {
@@ -4971,51 +7230,59 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>optional string value = 5;</code>
+       * <code>optional string value = 7;</code>
        */
       public Builder setValue(
           java.lang.String value) {
         if (value == null) {
     throw new NullPointerException();
   }
-  bitField0_ |= 0x00000010;
+  bitField0_ |= 0x00000040;
         value_ = value;
         onChanged();
         return this;
       }
       /**
-       * <code>optional string value = 5;</code>
+       * <code>optional string value = 7;</code>
        */
       public Builder clearValue() {
-        bitField0_ = (bitField0_ & ~0x00000010);
+        bitField0_ = (bitField0_ & ~0x00000040);
         value_ = getDefaultInstance().getValue();
         onChanged();
         return this;
       }
       /**
-       * <code>optional string value = 5;</code>
+       * <code>optional string value = 7;</code>
        */
       public Builder setValueBytes(
           com.google.protobuf.ByteString value) {
         if (value == null) {
     throw new NullPointerException();
   }
-  bitField0_ |= 0x00000010;
+  bitField0_ |= 0x00000040;
         value_ = value;
         onChanged();
         return this;
       }
 
-      // optional string valueType = 6;
+      // optional string valueType = 8;
       private java.lang.Object valueType_ = "";
       /**
-       * <code>optional string valueType = 6;</code>
+       * <code>optional string valueType = 8;</code>
+       *
+       * <pre>
+       * @deprecated(use intValueType)
+       * </pre>
        */
       public boolean hasValueType() {
-        return ((bitField0_ & 0x00000020) == 0x00000020);
+        return ((bitField0_ & 0x00000080) == 0x00000080);
       }
       /**
-       * <code>optional string valueType = 6;</code>
+       * <code>optional string valueType = 8;</code>
+       *
+       * <pre>
+       * @deprecated(use intValueType)
+       * </pre>
        */
       public java.lang.String getValueType() {
         java.lang.Object ref = valueType_;
@@ -5029,93 +7296,331 @@ public final class NormalizedNodeMessages {
         }
       }
       /**
-       * <code>optional string valueType = 6;</code>
+       * <code>optional string valueType = 8;</code>
+       *
+       * <pre>
+       * @deprecated(use intValueType)
+       * </pre>
+       */
+      public com.google.protobuf.ByteString
+          getValueTypeBytes() {
+        java.lang.Object ref = valueType_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b =
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          valueType_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>optional string valueType = 8;</code>
+       *
+       * <pre>
+       * @deprecated(use intValueType)
+       * </pre>
+       */
+      public Builder setValueType(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000080;
+        valueType_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string valueType = 8;</code>
+       *
+       * <pre>
+       * @deprecated(use intValueType)
+       * </pre>
+       */
+      public Builder clearValueType() {
+        bitField0_ = (bitField0_ & ~0x00000080);
+        valueType_ = getDefaultInstance().getValueType();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string valueType = 8;</code>
+       *
+       * <pre>
+       * @deprecated(use intValueType)
+       * </pre>
+       */
+      public Builder setValueTypeBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000080;
+        valueType_ = value;
+        onChanged();
+        return this;
+      }
+
+      // optional int32 intValueType = 9;
+      private int intValueType_ ;
+      /**
+       * <code>optional int32 intValueType = 9;</code>
+       *
+       * <pre>
+       * instead of valueType
+       * </pre>
+       */
+      public boolean hasIntValueType() {
+        return ((bitField0_ & 0x00000100) == 0x00000100);
+      }
+      /**
+       * <code>optional int32 intValueType = 9;</code>
+       *
+       * <pre>
+       * instead of valueType
+       * </pre>
+       */
+      public int getIntValueType() {
+        return intValueType_;
+      }
+      /**
+       * <code>optional int32 intValueType = 9;</code>
+       *
+       * <pre>
+       * instead of valueType
+       * </pre>
+       */
+      public Builder setIntValueType(int value) {
+        bitField0_ |= 0x00000100;
+        intValueType_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional int32 intValueType = 9;</code>
+       *
+       * <pre>
+       * instead of valueType
+       * </pre>
+       */
+      public Builder clearIntValueType() {
+        bitField0_ = (bitField0_ & ~0x00000100);
+        intValueType_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;
+      private org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier instanceIdentifierValue_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.getDefaultInstance();
+      private com.google.protobuf.SingleFieldBuilder<
+          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder> instanceIdentifierValueBuilder_;
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;</code>
+       *
+       * <pre>
+       * Specific values
+       * </pre>
+       */
+      public boolean hasInstanceIdentifierValue() {
+        return ((bitField0_ & 0x00000200) == 0x00000200);
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;</code>
+       *
+       * <pre>
+       * Specific values
+       * </pre>
+       */
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier getInstanceIdentifierValue() {
+        if (instanceIdentifierValueBuilder_ == null) {
+          return instanceIdentifierValue_;
+        } else {
+          return instanceIdentifierValueBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;</code>
+       *
+       * <pre>
+       * Specific values
+       * </pre>
+       */
+      public Builder setInstanceIdentifierValue(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier value) {
+        if (instanceIdentifierValueBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          instanceIdentifierValue_ = value;
+          onChanged();
+        } else {
+          instanceIdentifierValueBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000200;
+        return this;
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;</code>
+       *
+       * <pre>
+       * Specific values
+       * </pre>
+       */
+      public Builder setInstanceIdentifierValue(
+          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder builderForValue) {
+        if (instanceIdentifierValueBuilder_ == null) {
+          instanceIdentifierValue_ = builderForValue.build();
+          onChanged();
+        } else {
+          instanceIdentifierValueBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000200;
+        return this;
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;</code>
+       *
+       * <pre>
+       * Specific values
+       * </pre>
        */
-      public com.google.protobuf.ByteString
-          getValueTypeBytes() {
-        java.lang.Object ref = valueType_;
-        if (ref instanceof String) {
-          com.google.protobuf.ByteString b =
-              com.google.protobuf.ByteString.copyFromUtf8(
-                  (java.lang.String) ref);
-          valueType_ = b;
-          return b;
+      public Builder mergeInstanceIdentifierValue(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier value) {
+        if (instanceIdentifierValueBuilder_ == null) {
+          if (((bitField0_ & 0x00000200) == 0x00000200) &&
+              instanceIdentifierValue_ != org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.getDefaultInstance()) {
+            instanceIdentifierValue_ =
+              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.newBuilder(instanceIdentifierValue_).mergeFrom(value).buildPartial();
+          } else {
+            instanceIdentifierValue_ = value;
+          }
+          onChanged();
         } else {
-          return (com.google.protobuf.ByteString) ref;
+          instanceIdentifierValueBuilder_.mergeFrom(value);
         }
+        bitField0_ |= 0x00000200;
+        return this;
       }
       /**
-       * <code>optional string valueType = 6;</code>
+       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;</code>
+       *
+       * <pre>
+       * Specific values
+       * </pre>
        */
-      public Builder setValueType(
-          java.lang.String value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000020;
-        valueType_ = value;
-        onChanged();
+      public Builder clearInstanceIdentifierValue() {
+        if (instanceIdentifierValueBuilder_ == null) {
+          instanceIdentifierValue_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.getDefaultInstance();
+          onChanged();
+        } else {
+          instanceIdentifierValueBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000200);
         return this;
       }
       /**
-       * <code>optional string valueType = 6;</code>
+       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;</code>
+       *
+       * <pre>
+       * Specific values
+       * </pre>
        */
-      public Builder clearValueType() {
-        bitField0_ = (bitField0_ & ~0x00000020);
-        valueType_ = getDefaultInstance().getValueType();
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder getInstanceIdentifierValueBuilder() {
+        bitField0_ |= 0x00000200;
         onChanged();
-        return this;
+        return getInstanceIdentifierValueFieldBuilder().getBuilder();
       }
       /**
-       * <code>optional string valueType = 6;</code>
+       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;</code>
+       *
+       * <pre>
+       * Specific values
+       * </pre>
        */
-      public Builder setValueTypeBytes(
-          com.google.protobuf.ByteString value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000020;
-        valueType_ = value;
-        onChanged();
-        return this;
+      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder getInstanceIdentifierValueOrBuilder() {
+        if (instanceIdentifierValueBuilder_ != null) {
+          return instanceIdentifierValueBuilder_.getMessageOrBuilder();
+        } else {
+          return instanceIdentifierValue_;
+        }
+      }
+      /**
+       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 10;</code>
+       *
+       * <pre>
+       * Specific values
+       * </pre>
+       */
+      private com.google.protobuf.SingleFieldBuilder<
+          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder>
+          getInstanceIdentifierValueFieldBuilder() {
+        if (instanceIdentifierValueBuilder_ == null) {
+          instanceIdentifierValueBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder>(
+                  instanceIdentifierValue_,
+                  getParentForChildren(),
+                  isClean());
+          instanceIdentifierValue_ = null;
+        }
+        return instanceIdentifierValueBuilder_;
       }
 
-      // repeated string bitsValue = 7;
+      // repeated string bitsValue = 11;
       private com.google.protobuf.LazyStringList bitsValue_ = com.google.protobuf.LazyStringArrayList.EMPTY;
       private void ensureBitsValueIsMutable() {
-        if (!((bitField0_ & 0x00000040) == 0x00000040)) {
+        if (!((bitField0_ & 0x00000400) == 0x00000400)) {
           bitsValue_ = new com.google.protobuf.LazyStringArrayList(bitsValue_);
-          bitField0_ |= 0x00000040;
+          bitField0_ |= 0x00000400;
          }
       }
       /**
-       * <code>repeated string bitsValue = 7;</code>
+       * <code>repeated string bitsValue = 11;</code>
+       *
+       * <pre>
+       * intValueType = Bits
+       * </pre>
        */
       public java.util.List<java.lang.String>
           getBitsValueList() {
         return java.util.Collections.unmodifiableList(bitsValue_);
       }
       /**
-       * <code>repeated string bitsValue = 7;</code>
+       * <code>repeated string bitsValue = 11;</code>
+       *
+       * <pre>
+       * intValueType = Bits
+       * </pre>
        */
       public int getBitsValueCount() {
         return bitsValue_.size();
       }
       /**
-       * <code>repeated string bitsValue = 7;</code>
+       * <code>repeated string bitsValue = 11;</code>
+       *
+       * <pre>
+       * intValueType = Bits
+       * </pre>
        */
       public java.lang.String getBitsValue(int index) {
         return bitsValue_.get(index);
       }
       /**
-       * <code>repeated string bitsValue = 7;</code>
+       * <code>repeated string bitsValue = 11;</code>
+       *
+       * <pre>
+       * intValueType = Bits
+       * </pre>
        */
       public com.google.protobuf.ByteString
           getBitsValueBytes(int index) {
         return bitsValue_.getByteString(index);
       }
       /**
-       * <code>repeated string bitsValue = 7;</code>
+       * <code>repeated string bitsValue = 11;</code>
+       *
+       * <pre>
+       * intValueType = Bits
+       * </pre>
        */
       public Builder setBitsValue(
           int index, java.lang.String value) {
@@ -5128,7 +7633,11 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated string bitsValue = 7;</code>
+       * <code>repeated string bitsValue = 11;</code>
+       *
+       * <pre>
+       * intValueType = Bits
+       * </pre>
        */
       public Builder addBitsValue(
           java.lang.String value) {
@@ -5141,7 +7650,11 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated string bitsValue = 7;</code>
+       * <code>repeated string bitsValue = 11;</code>
+       *
+       * <pre>
+       * intValueType = Bits
+       * </pre>
        */
       public Builder addAllBitsValue(
           java.lang.Iterable<java.lang.String> values) {
@@ -5151,16 +7664,24 @@ public final class NormalizedNodeMessages {
         return this;
       }
       /**
-       * <code>repeated string bitsValue = 7;</code>
+       * <code>repeated string bitsValue = 11;</code>
+       *
+       * <pre>
+       * intValueType = Bits
+       * </pre>
        */
       public Builder clearBitsValue() {
         bitsValue_ = com.google.protobuf.LazyStringArrayList.EMPTY;
-        bitField0_ = (bitField0_ & ~0x00000040);
+        bitField0_ = (bitField0_ & ~0x00000400);
         onChanged();
         return this;
       }
       /**
-       * <code>repeated string bitsValue = 7;</code>
+       * <code>repeated string bitsValue = 11;</code>
+       *
+       * <pre>
+       * intValueType = Bits
+       * </pre>
        */
       public Builder addBitsValueBytes(
           com.google.protobuf.ByteString value) {
@@ -5173,121 +7694,133 @@ public final class NormalizedNodeMessages {
         return this;
       }
 
-      // optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;
-      private org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier instanceIdentifierValue_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.getDefaultInstance();
-      private com.google.protobuf.SingleFieldBuilder<
-          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder> instanceIdentifierValueBuilder_;
+      // repeated string code = 12;
+      private com.google.protobuf.LazyStringList code_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+      private void ensureCodeIsMutable() {
+        if (!((bitField0_ & 0x00000800) == 0x00000800)) {
+          code_ = new com.google.protobuf.LazyStringArrayList(code_);
+          bitField0_ |= 0x00000800;
+         }
+      }
       /**
-       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;</code>
+       * <code>repeated string code = 12;</code>
+       *
+       * <pre>
+       * A list of string codes which can be used for any repeated strings in the NormalizedNode
+       * </pre>
        */
-      public boolean hasInstanceIdentifierValue() {
-        return ((bitField0_ & 0x00000080) == 0x00000080);
+      public java.util.List<java.lang.String>
+          getCodeList() {
+        return java.util.Collections.unmodifiableList(code_);
       }
       /**
-       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;</code>
+       * <code>repeated string code = 12;</code>
+       *
+       * <pre>
+       * A list of string codes which can be used for any repeated strings in the NormalizedNode
+       * </pre>
        */
-      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier getInstanceIdentifierValue() {
-        if (instanceIdentifierValueBuilder_ == null) {
-          return instanceIdentifierValue_;
-        } else {
-          return instanceIdentifierValueBuilder_.getMessage();
-        }
+      public int getCodeCount() {
+        return code_.size();
       }
       /**
-       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;</code>
+       * <code>repeated string code = 12;</code>
+       *
+       * <pre>
+       * A list of string codes which can be used for any repeated strings in the NormalizedNode
+       * </pre>
        */
-      public Builder setInstanceIdentifierValue(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier value) {
-        if (instanceIdentifierValueBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          instanceIdentifierValue_ = value;
-          onChanged();
-        } else {
-          instanceIdentifierValueBuilder_.setMessage(value);
-        }
-        bitField0_ |= 0x00000080;
-        return this;
+      public java.lang.String getCode(int index) {
+        return code_.get(index);
       }
       /**
-       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;</code>
+       * <code>repeated string code = 12;</code>
+       *
+       * <pre>
+       * A list of string codes which can be used for any repeated strings in the NormalizedNode
+       * </pre>
        */
-      public Builder setInstanceIdentifierValue(
-          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder builderForValue) {
-        if (instanceIdentifierValueBuilder_ == null) {
-          instanceIdentifierValue_ = builderForValue.build();
-          onChanged();
-        } else {
-          instanceIdentifierValueBuilder_.setMessage(builderForValue.build());
-        }
-        bitField0_ |= 0x00000080;
-        return this;
+      public com.google.protobuf.ByteString
+          getCodeBytes(int index) {
+        return code_.getByteString(index);
       }
       /**
-       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;</code>
+       * <code>repeated string code = 12;</code>
+       *
+       * <pre>
+       * A list of string codes which can be used for any repeated strings in the NormalizedNode
+       * </pre>
        */
-      public Builder mergeInstanceIdentifierValue(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier value) {
-        if (instanceIdentifierValueBuilder_ == null) {
-          if (((bitField0_ & 0x00000080) == 0x00000080) &&
-              instanceIdentifierValue_ != org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.getDefaultInstance()) {
-            instanceIdentifierValue_ =
-              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.newBuilder(instanceIdentifierValue_).mergeFrom(value).buildPartial();
-          } else {
-            instanceIdentifierValue_ = value;
-          }
-          onChanged();
-        } else {
-          instanceIdentifierValueBuilder_.mergeFrom(value);
-        }
-        bitField0_ |= 0x00000080;
+      public Builder setCode(
+          int index, java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  ensureCodeIsMutable();
+        code_.set(index, value);
+        onChanged();
         return this;
       }
       /**
-       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;</code>
+       * <code>repeated string code = 12;</code>
+       *
+       * <pre>
+       * A list of string codes which can be used for any repeated strings in the NormalizedNode
+       * </pre>
        */
-      public Builder clearInstanceIdentifierValue() {
-        if (instanceIdentifierValueBuilder_ == null) {
-          instanceIdentifierValue_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.getDefaultInstance();
-          onChanged();
-        } else {
-          instanceIdentifierValueBuilder_.clear();
-        }
-        bitField0_ = (bitField0_ & ~0x00000080);
+      public Builder addCode(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  ensureCodeIsMutable();
+        code_.add(value);
+        onChanged();
         return this;
       }
       /**
-       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;</code>
+       * <code>repeated string code = 12;</code>
+       *
+       * <pre>
+       * A list of string codes which can be used for any repeated strings in the NormalizedNode
+       * </pre>
        */
-      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder getInstanceIdentifierValueBuilder() {
-        bitField0_ |= 0x00000080;
+      public Builder addAllCode(
+          java.lang.Iterable<java.lang.String> values) {
+        ensureCodeIsMutable();
+        super.addAll(values, code_);
         onChanged();
-        return getInstanceIdentifierValueFieldBuilder().getBuilder();
+        return this;
       }
       /**
-       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;</code>
+       * <code>repeated string code = 12;</code>
+       *
+       * <pre>
+       * A list of string codes which can be used for any repeated strings in the NormalizedNode
+       * </pre>
        */
-      public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder getInstanceIdentifierValueOrBuilder() {
-        if (instanceIdentifierValueBuilder_ != null) {
-          return instanceIdentifierValueBuilder_.getMessageOrBuilder();
-        } else {
-          return instanceIdentifierValue_;
-        }
+      public Builder clearCode() {
+        code_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+        bitField0_ = (bitField0_ & ~0x00000800);
+        onChanged();
+        return this;
       }
       /**
-       * <code>optional .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierValue = 8;</code>
+       * <code>repeated string code = 12;</code>
+       *
+       * <pre>
+       * A list of string codes which can be used for any repeated strings in the NormalizedNode
+       * </pre>
        */
-      private com.google.protobuf.SingleFieldBuilder<
-          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder>
-          getInstanceIdentifierValueFieldBuilder() {
-        if (instanceIdentifierValueBuilder_ == null) {
-          instanceIdentifierValueBuilder_ = new com.google.protobuf.SingleFieldBuilder<
-              org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder>(
-                  instanceIdentifierValue_,
-                  getParentForChildren(),
-                  isClean());
-          instanceIdentifierValue_ = null;
-        }
-        return instanceIdentifierValueBuilder_;
+      public Builder addCodeBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  ensureCodeIsMutable();
+        code_.add(value);
+        onChanged();
+        return this;
       }
 
       // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.Node)
@@ -7402,6 +9935,11 @@ public final class NormalizedNodeMessages {
   private static
     com.google.protobuf.GeneratedMessage.FieldAccessorTable
       internal_static_org_opendaylight_controller_mdsal_Attribute_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_org_opendaylight_controller_mdsal_PathArgumentAttribute_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_org_opendaylight_controller_mdsal_PathArgumentAttribute_fieldAccessorTable;
   private static com.google.protobuf.Descriptors.Descriptor
     internal_static_org_opendaylight_controller_mdsal_QName_descriptor;
   private static
@@ -7448,32 +9986,42 @@ public final class NormalizedNodeMessages {
     java.lang.String[] descriptorData = {
       "\n\014Common.proto\022!org.opendaylight.control" +
       "ler.mdsal\"6\n\tAttribute\022\014\n\004name\030\001 \002(\t\022\r\n\005" +
-      "value\030\002 \001(\t\022\014\n\004type\030\003 \001(\t\"\026\n\005QName\022\r\n\005va" +
-      "lue\030\001 \002(\t\"\251\001\n\014PathArgument\022\r\n\005value\030\001 \002(" +
-      "\t\022\014\n\004type\030\002 \001(\t\022:\n\010nodeType\030\003 \001(\0132(.org." +
-      "opendaylight.controller.mdsal.QName\022@\n\na" +
-      "ttributes\030\004 \003(\0132,.org.opendaylight.contr" +
-      "oller.mdsal.Attribute\"X\n\022InstanceIdentif" +
-      "ier\022B\n\targuments\030\001 \003(\0132/.org.opendayligh" +
-      "t.controller.mdsal.PathArgument\"\251\002\n\004Node",
-      "\022\014\n\004path\030\001 \001(\t\022\014\n\004type\030\002 \001(\t\022@\n\nattribut" +
-      "es\030\003 \003(\0132,.org.opendaylight.controller.m" +
-      "dsal.Attribute\0226\n\005child\030\004 \003(\0132\'.org.open" +
-      "daylight.controller.mdsal.Node\022\r\n\005value\030" +
-      "\005 \001(\t\022\021\n\tvalueType\030\006 \001(\t\022\021\n\tbitsValue\030\007 " +
-      "\003(\t\022V\n\027instanceIdentifierValue\030\010 \001(\01325.o" +
-      "rg.opendaylight.controller.mdsal.Instanc" +
-      "eIdentifier\"`\n\tContainer\022\022\n\nparentPath\030\001" +
-      " \002(\t\022?\n\016normalizedNode\030\002 \001(\0132\'.org.opend" +
-      "aylight.controller.mdsal.Node\"\246\001\n\014NodeMa",
-      "pEntry\022U\n\026instanceIdentifierPath\030\001 \002(\01325" +
-      ".org.opendaylight.controller.mdsal.Insta" +
-      "nceIdentifier\022?\n\016normalizedNode\030\002 \001(\0132\'." +
-      "org.opendaylight.controller.mdsal.Node\"N" +
-      "\n\007NodeMap\022C\n\nmapEntries\030\001 \003(\0132/.org.open" +
-      "daylight.controller.mdsal.NodeMapEntryBO" +
-      "\n5org.opendaylight.controller.protobuff." +
-      "messages.commonB\026NormalizedNodeMessages"
+      "value\030\002 \001(\t\022\014\n\004type\030\003 \001(\t\"l\n\025PathArgumen" +
+      "tAttribute\0226\n\004name\030\001 \001(\0132(.org.opendayli" +
+      "ght.controller.mdsal.QName\022\r\n\005value\030\002 \001(" +
+      "\t\022\014\n\004type\030\003 \001(\005\"N\n\005QName\022\r\n\005value\030\001 \001(\t\022" +
+      "\021\n\tnamespace\030\002 \001(\005\022\020\n\010revision\030\003 \001(\005\022\021\n\t" +
+      "localName\030\004 \001(\005\"\207\002\n\014PathArgument\022\r\n\005valu" +
+      "e\030\001 \001(\t\022\014\n\004type\030\002 \001(\t\022:\n\010nodeType\030\003 \001(\0132" +
+      "(.org.opendaylight.controller.mdsal.QNam",
+      "e\022K\n\tattribute\030\004 \003(\01328.org.opendaylight." +
+      "controller.mdsal.PathArgumentAttribute\022@" +
+      "\n\nattributes\030\005 \003(\0132,.org.opendaylight.co" +
+      "ntroller.mdsal.Attribute\022\017\n\007intType\030\006 \001(" +
+      "\005\"X\n\022InstanceIdentifier\022B\n\targuments\030\001 \003" +
+      "(\0132/.org.opendaylight.controller.mdsal.P" +
+      "athArgument\"\245\003\n\004Node\022\014\n\004path\030\001 \001(\t\022\014\n\004ty" +
+      "pe\030\002 \001(\t\022E\n\014pathArgument\030\003 \001(\0132/.org.ope" +
+      "ndaylight.controller.mdsal.PathArgument\022" +
+      "\017\n\007intType\030\004 \001(\005\022@\n\nattributes\030\005 \003(\0132,.o",
+      "rg.opendaylight.controller.mdsal.Attribu" +
+      "te\0226\n\005child\030\006 \003(\0132\'.org.opendaylight.con" +
+      "troller.mdsal.Node\022\r\n\005value\030\007 \001(\t\022\021\n\tval" +
+      "ueType\030\010 \001(\t\022\024\n\014intValueType\030\t \001(\005\022V\n\027in" +
+      "stanceIdentifierValue\030\n \001(\01325.org.openda" +
+      "ylight.controller.mdsal.InstanceIdentifi" +
+      "er\022\021\n\tbitsValue\030\013 \003(\t\022\014\n\004code\030\014 \003(\t\"`\n\tC" +
+      "ontainer\022\022\n\nparentPath\030\001 \002(\t\022?\n\016normaliz" +
+      "edNode\030\002 \001(\0132\'.org.opendaylight.controll" +
+      "er.mdsal.Node\"\246\001\n\014NodeMapEntry\022U\n\026instan",
+      "ceIdentifierPath\030\001 \002(\01325.org.opendayligh" +
+      "t.controller.mdsal.InstanceIdentifier\022?\n" +
+      "\016normalizedNode\030\002 \001(\0132\'.org.opendaylight" +
+      ".controller.mdsal.Node\"N\n\007NodeMap\022C\n\nmap" +
+      "Entries\030\001 \003(\0132/.org.opendaylight.control" +
+      "ler.mdsal.NodeMapEntryBO\n5org.opendaylig" +
+      "ht.controller.protobuff.messages.commonB" +
+      "\026NormalizedNodeMessages"
     };
     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
@@ -7486,44 +10034,50 @@ public final class NormalizedNodeMessages {
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_org_opendaylight_controller_mdsal_Attribute_descriptor,
               new java.lang.String[] { "Name", "Value", "Type", });
-          internal_static_org_opendaylight_controller_mdsal_QName_descriptor =
+          internal_static_org_opendaylight_controller_mdsal_PathArgumentAttribute_descriptor =
             getDescriptor().getMessageTypes().get(1);
+          internal_static_org_opendaylight_controller_mdsal_PathArgumentAttribute_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_org_opendaylight_controller_mdsal_PathArgumentAttribute_descriptor,
+              new java.lang.String[] { "Name", "Value", "Type", });
+          internal_static_org_opendaylight_controller_mdsal_QName_descriptor =
+            getDescriptor().getMessageTypes().get(2);
           internal_static_org_opendaylight_controller_mdsal_QName_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_org_opendaylight_controller_mdsal_QName_descriptor,
-              new java.lang.String[] { "Value", });
+              new java.lang.String[] { "Value", "Namespace", "Revision", "LocalName", });
           internal_static_org_opendaylight_controller_mdsal_PathArgument_descriptor =
-            getDescriptor().getMessageTypes().get(2);
+            getDescriptor().getMessageTypes().get(3);
           internal_static_org_opendaylight_controller_mdsal_PathArgument_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_org_opendaylight_controller_mdsal_PathArgument_descriptor,
-              new java.lang.String[] { "Value", "Type", "NodeType", "Attributes", });
+              new java.lang.String[] { "Value", "Type", "NodeType", "Attribute", "Attributes", "IntType", });
           internal_static_org_opendaylight_controller_mdsal_InstanceIdentifier_descriptor =
-            getDescriptor().getMessageTypes().get(3);
+            getDescriptor().getMessageTypes().get(4);
           internal_static_org_opendaylight_controller_mdsal_InstanceIdentifier_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_org_opendaylight_controller_mdsal_InstanceIdentifier_descriptor,
               new java.lang.String[] { "Arguments", });
           internal_static_org_opendaylight_controller_mdsal_Node_descriptor =
-            getDescriptor().getMessageTypes().get(4);
+            getDescriptor().getMessageTypes().get(5);
           internal_static_org_opendaylight_controller_mdsal_Node_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_org_opendaylight_controller_mdsal_Node_descriptor,
-              new java.lang.String[] { "Path", "Type", "Attributes", "Child", "Value", "ValueType", "BitsValue", "InstanceIdentifierValue", });
+              new java.lang.String[] { "Path", "Type", "PathArgument", "IntType", "Attributes", "Child", "Value", "ValueType", "IntValueType", "InstanceIdentifierValue", "BitsValue", "Code", });
           internal_static_org_opendaylight_controller_mdsal_Container_descriptor =
-            getDescriptor().getMessageTypes().get(5);
+            getDescriptor().getMessageTypes().get(6);
           internal_static_org_opendaylight_controller_mdsal_Container_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_org_opendaylight_controller_mdsal_Container_descriptor,
               new java.lang.String[] { "ParentPath", "NormalizedNode", });
           internal_static_org_opendaylight_controller_mdsal_NodeMapEntry_descriptor =
-            getDescriptor().getMessageTypes().get(6);
+            getDescriptor().getMessageTypes().get(7);
           internal_static_org_opendaylight_controller_mdsal_NodeMapEntry_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_org_opendaylight_controller_mdsal_NodeMapEntry_descriptor,
               new java.lang.String[] { "InstanceIdentifierPath", "NormalizedNode", });
           internal_static_org_opendaylight_controller_mdsal_NodeMap_descriptor =
-            getDescriptor().getMessageTypes().get(7);
+            getDescriptor().getMessageTypes().get(8);
           internal_static_org_opendaylight_controller_mdsal_NodeMap_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_org_opendaylight_controller_mdsal_NodeMap_descriptor,
index bdd66d3..ded8071 100644 (file)
@@ -6945,11 +6945,11 @@ public final class ShardTransactionMessages {
 
       public final boolean isInitialized() {
         if (!hasInstanceIdentifierPathArguments()) {
-          
+
           return false;
         }
         if (!getInstanceIdentifierPathArguments().isInitialized()) {
-          
+
           return false;
         }
         return true;
@@ -7078,7 +7078,7 @@ public final class ShardTransactionMessages {
        * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPathArguments = 1;</code>
        */
       private com.google.protobuf.SingleFieldBuilder<
-          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder> 
+          org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder>
           getInstanceIdentifierPathArgumentsFieldBuilder() {
         if (instanceIdentifierPathArgumentsBuilder_ == null) {
           instanceIdentifierPathArgumentsBuilder_ = new com.google.protobuf.SingleFieldBuilder<
@@ -7437,7 +7437,7 @@ public final class ShardTransactionMessages {
 
       public final boolean isInitialized() {
         if (!hasExists()) {
-          
+
           return false;
         }
         return true;
index 59d78dd..0b3ff21 100644 (file)
@@ -10,16 +10,29 @@ message Attribute{
   optional string type=3;
 }
 
+message PathArgumentAttribute{
+    optional QName name =1;
+    optional string value=2;
+    optional int32 type=3;
+}
+
+
 message QName {
-    required string value=1;
+    optional string value=1; // @deprecated
+    optional int32 namespace=2;
+    optional int32 revision=3;
+    optional int32 localName=4;
 }
 
 message PathArgument {
-  required string value=1;
-  optional string type=2; //NodeIdentifier, NodeWithValue, NodeIdentifierWithPredicates
+  optional string value=1; // @deprecated
+  optional string type=2; // @deprecated
+
   optional QName nodeType=3;
-  repeated Attribute attributes=4;
 
+  repeated PathArgumentAttribute attribute=4;
+  repeated Attribute attributes=5; // @deprecated For backward compatibility (see InstanceIdentifierUtils)
+  optional int32 intType = 6;
 }
 
 message InstanceIdentifier {
@@ -27,14 +40,24 @@ message InstanceIdentifier {
 }
 
 message Node{
-  optional string path = 1;
-  optional string type = 2;
-  repeated Attribute attributes = 3;
-  repeated Node child=4;
-  optional string value = 5;
-  optional string valueType = 6;
-  repeated string bitsValue = 7;
-  optional InstanceIdentifier instanceIdentifierValue = 8;
+  optional string path = 1; // @deprecated(use pathArgument)
+  optional string type = 2; // @deprecated(use intType)
+  optional PathArgument pathArgument = 3;
+  optional int32 intType = 4;
+
+  repeated Attribute attributes = 5;
+
+  repeated Node child = 6;
+
+  optional string value = 7;
+  optional string valueType = 8; // @deprecated(use intValueType)
+  optional int32 intValueType = 9; // instead of valueType
+
+  // Specific values
+  optional InstanceIdentifier instanceIdentifierValue = 10; // intValueType = YangInstanceIdentifier
+  repeated string bitsValue = 11; // intValueType = Bits
+
+  repeated string code = 12; // A list of string codes which can be used for any repeated strings in the NormalizedNode
 }
 
 message Container{
index c42865c..a9f9c72 100644 (file)
 
 package org.opendaylight.controller.cluster.datastore.node;
 
-import junit.framework.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.opendaylight.controller.cluster.datastore.node.utils.NormalizedNodeGetter;
 import org.opendaylight.controller.cluster.datastore.node.utils.NormalizedNodeNavigator;
 import org.opendaylight.controller.cluster.datastore.node.utils.PathUtils;
+import org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeSerializer;
 import org.opendaylight.controller.cluster.datastore.util.TestModel;
 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Container;
 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node;
@@ -28,6 +28,7 @@ import java.util.List;
 
 import static junit.framework.Assert.assertEquals;
 import static junit.framework.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
 
 public class NormalizedNodeToNodeCodecTest {
 
@@ -74,7 +75,8 @@ public class NormalizedNodeToNodeCodecTest {
 
     assertNotNull(container);
     assertEquals(id, container.getParentPath() + "/"
-        + container.getNormalizedNode().getPath());
+        + NormalizedNodeSerializer.deSerialize(container.getNormalizedNode(),
+        container.getNormalizedNode().getPathArgument()));
 
     // Decode the normalized node from the ProtocolBuffer form
     // first get the node representation of normalized node
@@ -109,7 +111,7 @@ public class NormalizedNodeToNodeCodecTest {
             .decode(
                 instanceIdentifierFromString("/(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test"),
                 container.getNormalizedNode());
-    assertNotNull(decode != null);
+    assertNotNull(decode);
 
     // let us ensure that the return decode normalized node encode returns same container
     Container containerResult =
@@ -117,10 +119,8 @@ public class NormalizedNodeToNodeCodecTest {
             .build(), decode);
 
     assertEquals(container.getParentPath(), containerResult.getParentPath());
-    assertEquals(container.getNormalizedNode().getChildCount(), container
-        .getNormalizedNode().getChildCount());
 
-    Assert.assertEquals(containerResult.getNormalizedNode().getChildCount(),
+    assertEquals(containerResult.getNormalizedNode().getChildCount(),
         container.getNormalizedNode().getChildCount());
 
     // check first level children are proper
@@ -140,13 +140,22 @@ public class NormalizedNodeToNodeCodecTest {
     for (Node resultChild : childrenResult) {
       bFound = false;
       for (Node originalChild : childrenOriginal) {
-        if (originalChild.getPath().equals(resultChild.getPath())
-            && resultChild.getType().equals(resultChild.getType())) {
+
+        YangInstanceIdentifier.PathArgument result = NormalizedNodeSerializer.deSerialize(
+              containerResult.getNormalizedNode(),
+              resultChild.getPathArgument());
+
+          YangInstanceIdentifier.PathArgument original = NormalizedNodeSerializer.deSerialize(
+              container.getNormalizedNode(),
+              originalChild.getPathArgument());
+
+        if (original.equals(result)
+            && resultChild.getIntType() == resultChild.getIntType()) {
           bFound = true;
           break;
         }
       }
-      Assert.assertTrue(bFound);
+      assertTrue(bFound);
     }
 
   }
diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeSerializerTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/NormalizedNodeSerializerTest.java
new file mode 100644 (file)
index 0000000..cdb2e69
--- /dev/null
@@ -0,0 +1,127 @@
+package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
+
+import org.junit.Rule;
+import org.junit.Test;
+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.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class NormalizedNodeSerializerTest {
+
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Test
+    public void testSerializeDeSerialize(){
+
+        // This test basically serializes and deSerializes a largish document
+        // which contains most of the types of nodes that go into a normalized
+        // node and uses several value types as well. It is in general a good
+        // sanity test which could be augmented with specific unit tests.
+
+        long start = System.nanoTime();
+
+        NormalizedNode<?, ?> expectedNode =
+            TestModel.createDocumentOne(TestModel.createTestContext());
+
+        NormalizedNodeMessages.Node expected = NormalizedNodeSerializer
+            .serialize(expectedNode);
+
+        System.out.println("Serialize Time = " + (System.nanoTime() - start)/1000000);
+
+        System.out.println("Serialized Size = " + expected.getSerializedSize());
+
+        System.out.println(expected.toString());
+
+        start = System.nanoTime();
+
+        NormalizedNode actualNode =
+            NormalizedNodeSerializer.deSerialize(expected);
+
+        System.out.println("DeSerialize Time = " + (System.nanoTime() - start)/1000000);
+
+        // Compare the original normalized node to the normalized node that was
+        // created by serializing the original node and deSerializing it back.
+        assertEquals(expectedNode, actualNode);
+
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testSerializeNullNormalizedNode(){
+        assertNotNull(NormalizedNodeSerializer.serialize(null));
+    }
+
+    @Test
+    public void testDeSerializeNullProtocolBufferNode(){
+        expectedException.expect(NullPointerException.class);
+        expectedException.expectMessage("node should not be null");
+
+        NormalizedNodeSerializer.deSerialize(null);
+    }
+
+    @Test
+    public void testDeSerializePathArgumentNullNode(){
+        expectedException.expect(NullPointerException.class);
+        expectedException.expectMessage("node should not be null");
+
+        NormalizedNodeSerializer
+            .deSerialize(null, NormalizedNodeMessages.PathArgument.getDefaultInstance());
+    }
+
+    @Test
+    public void testDeSerializePathArgumentNullPathArgument(){
+        expectedException.expect(NullPointerException.class);
+        expectedException.expectMessage("pathArgument should not be null");
+
+        NormalizedNodeSerializer.deSerialize(NormalizedNodeMessages.Node.getDefaultInstance() , null);
+    }
+
+    @Test
+    public void testDeSerializePathArgument(){
+
+        NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
+
+        nodeBuilder.addCode("urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test1");
+        nodeBuilder.addCode("urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test");
+
+
+        nodeBuilder.addCode("2014-04-13");
+        nodeBuilder.addCode("2014-05-13");
+        nodeBuilder.addCode("2014-03-13");
+
+        nodeBuilder.addCode("dummy1");
+        nodeBuilder.addCode("dummy2");
+        nodeBuilder.addCode("dummy3");
+        nodeBuilder.addCode("capability");
+
+
+
+        NormalizedNodeMessages.PathArgument.Builder pathBuilder = NormalizedNodeMessages.PathArgument.newBuilder();
+
+        pathBuilder.setIntType(PathArgumentType.NODE_IDENTIFIER.ordinal());
+
+        NormalizedNodeMessages.QName.Builder qNameBuilder = NormalizedNodeMessages.QName.newBuilder();
+        qNameBuilder.setNamespace(1);
+        qNameBuilder.setRevision(4);
+        qNameBuilder.setLocalName(8);
+
+        pathBuilder.setNodeType(qNameBuilder);
+
+        YangInstanceIdentifier.PathArgument pathArgument =
+            NormalizedNodeSerializer
+                .deSerialize(nodeBuilder.build(), pathBuilder.build());
+
+        assertNotNull(pathArgument);
+
+        assertEquals("urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test", pathArgument.getNodeType().getNamespace().toString());
+        assertEquals("2014-03-13", pathArgument.getNodeType().getFormattedRevision());
+        assertEquals("capability", pathArgument.getNodeType().getLocalName());
+    }
+
+
+}
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
new file mode 100644 (file)
index 0000000..d1f21ee
--- /dev/null
@@ -0,0 +1,280 @@
+package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import org.junit.Rule;
+import org.junit.Test;
+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.yangtools.yang.data.api.YangInstanceIdentifier;
+
+import java.net.URI;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class PathArgumentSerializerTest{
+
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Test
+    public void testSerializeNullContext(){
+        expectedException.expect(NullPointerException.class);
+        expectedException.expectMessage("context should not be null");
+
+        PathArgumentSerializer.serialize(null, mock(
+            YangInstanceIdentifier.PathArgument.class));
+    }
+
+    @Test
+    public void testSerializeNullPathArgument(){
+        expectedException.expect(NullPointerException.class);
+        expectedException.expectMessage("pathArgument should not be null");
+
+        PathArgumentSerializer.serialize(mock(
+            NormalizedNodeSerializationContext.class), null);
+
+    }
+
+    @Test
+    public void testDeSerializeNullContext(){
+        expectedException.expect(NullPointerException.class);
+        expectedException.expectMessage("context should not be null");
+
+        PathArgumentSerializer.deSerialize(null, NormalizedNodeMessages.PathArgument.getDefaultInstance());
+
+    }
+
+    @Test
+    public void testDeSerializeNullPathArgument(){
+        expectedException.expect(NullPointerException.class);
+        expectedException.expectMessage("pathArgument should not be null");
+
+        PathArgumentSerializer.deSerialize(mock(NormalizedNodeDeSerializationContext.class), null);
+
+    }
+
+    @Test
+    public void testSerializeNodeIdentifier(){
+        NormalizedNodeSerializationContext serializationContext =
+            mock(NormalizedNodeSerializationContext.class);
+
+        when(serializationContext.addLocalName(anyString())).thenReturn(5);
+        when(serializationContext.addNamespace(any(URI.class))).thenReturn(10);
+        when(serializationContext.addRevision(any(Date.class))).thenReturn(11);
+
+        NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
+            .serialize(serializationContext,
+                new YangInstanceIdentifier.NodeIdentifier(
+                    TestModel.TEST_QNAME));
+
+        assertEquals(PathArgumentType.NODE_IDENTIFIER.ordinal(), actual.getIntType());
+        assertEquals(5, actual.getNodeType().getLocalName());
+        assertEquals(10, actual.getNodeType().getNamespace());
+        assertEquals(11, actual.getNodeType().getRevision());
+
+
+    }
+
+    @Test
+    public void testSerializeNodeIdentifierWithValue(){
+        NormalizedNodeSerializationContext serializationContext =
+            mock(NormalizedNodeSerializationContext.class);
+
+        when(serializationContext.addLocalName(anyString())).thenReturn(5);
+        when(serializationContext.addNamespace(any(URI.class))).thenReturn(10);
+        when(serializationContext.addRevision(any(Date.class))).thenReturn(11);
+
+        NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
+            .serialize(serializationContext,
+                new YangInstanceIdentifier.NodeWithValue(
+                    TestModel.TEST_QNAME, "foo"));
+
+        assertEquals(PathArgumentType.NODE_IDENTIFIER_WITH_VALUE.ordinal(), actual.getIntType());
+        assertEquals(5, actual.getNodeType().getLocalName());
+        assertEquals(10, actual.getNodeType().getNamespace());
+        assertEquals(11, actual.getNodeType().getRevision());
+        assertEquals("foo", actual.getAttribute(0).getValue());
+
+
+    }
+
+    @Test
+    public void testSerializeNodeIdentifierWithPredicates(){
+        NormalizedNodeSerializationContext serializationContext =
+            mock(NormalizedNodeSerializationContext.class);
+
+
+        when(serializationContext.addLocalName("test")).thenReturn(5);
+        when(serializationContext.addLocalName("child-name")).thenReturn(55);
+
+        when(serializationContext.addNamespace(TestModel.TEST_QNAME.getNamespace())).thenReturn(
+            10);
+        when(serializationContext.addNamespace(TestModel.CHILD_NAME_QNAME.getNamespace())).thenReturn(66);
+
+        when(serializationContext.addRevision(TestModel.TEST_QNAME.getRevision())).thenReturn(
+            11);
+        when(serializationContext.addRevision(TestModel.CHILD_NAME_QNAME.getRevision())).thenReturn(77);
+
+        Map<QName, Object> predicates = new HashMap<>();
+
+        predicates.put(TestModel.CHILD_NAME_QNAME, "foobar");
+
+        NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
+            .serialize(serializationContext,
+                new YangInstanceIdentifier.NodeIdentifierWithPredicates(
+                    TestModel.TEST_QNAME, predicates));
+
+        assertEquals(PathArgumentType.NODE_IDENTIFIER_WITH_PREDICATES.ordinal(), actual.getIntType());
+        assertEquals(5, actual.getNodeType().getLocalName());
+        assertEquals(10, actual.getNodeType().getNamespace());
+        assertEquals(11, actual.getNodeType().getRevision());
+
+        assertEquals(55, actual.getAttribute(0).getName().getLocalName());
+        assertEquals(66, actual.getAttribute(0).getName().getNamespace());
+        assertEquals(77, actual.getAttribute(0).getName().getRevision());
+
+        assertEquals("foobar", actual.getAttribute(0).getValue());
+
+
+    }
+
+    @Test
+    public void testSerializeAugmentationIdentifier(){
+        NormalizedNodeSerializationContext serializationContext =
+            mock(NormalizedNodeSerializationContext.class);
+
+        when(serializationContext.addLocalName(anyString())).thenReturn(55);
+        when(serializationContext.addNamespace(any(URI.class))).thenReturn(66);
+        when(serializationContext.addRevision(any(Date.class))).thenReturn(77);
+
+        NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
+            .serialize(serializationContext,
+                new YangInstanceIdentifier.AugmentationIdentifier(
+                    ImmutableSet.of(TestModel.TEST_QNAME)));
+
+        assertEquals(PathArgumentType.AUGMENTATION_IDENTIFIER.ordinal(), actual.getIntType());
+
+        assertEquals(55, actual.getAttribute(0).getName().getLocalName());
+        assertEquals(66, actual.getAttribute(0).getName().getNamespace());
+        assertEquals(77, actual.getAttribute(0).getName().getRevision());
+
+    }
+
+    @Test
+    public void testDeSerializeNodeIdentifier(){
+
+        NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
+        NormalizedNodeMessages.PathArgument.Builder pathBuilder = NormalizedNodeMessages.PathArgument.newBuilder();
+        NormalizedNodeMessages.QName.Builder qNameBuilder = NormalizedNodeMessages.QName.newBuilder();
+
+        qNameBuilder.setNamespace(0);
+        qNameBuilder.setRevision(1);
+        qNameBuilder.setLocalName(2);
+
+        pathBuilder.setNodeType(qNameBuilder);
+        pathBuilder.setIntType(PathArgumentType.NODE_IDENTIFIER.ordinal());
+
+        nodeBuilder.addCode(TestModel.TEST_QNAME.getNamespace().toString());
+        nodeBuilder.addCode(TestModel.TEST_QNAME.getFormattedRevision());
+        nodeBuilder.addCode(TestModel.TEST_QNAME.getLocalName());
+
+        YangInstanceIdentifier.PathArgument pathArgument =
+            NormalizedNodeSerializer
+                .deSerialize(nodeBuilder.build(), pathBuilder.build());
+
+        assertEquals(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME), pathArgument);
+
+    }
+
+    @Test
+    public void testDeSerializeNodeWithValue(){
+        NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
+        NormalizedNodeMessages.PathArgument.Builder pathBuilder = NormalizedNodeMessages.PathArgument.newBuilder();
+        NormalizedNodeMessages.QName.Builder qNameBuilder = NormalizedNodeMessages.QName.newBuilder();
+
+        qNameBuilder.setNamespace(0);
+        qNameBuilder.setRevision(1);
+        qNameBuilder.setLocalName(2);
+
+        pathBuilder.setNodeType(qNameBuilder);
+        pathBuilder.setIntType(PathArgumentType.NODE_IDENTIFIER_WITH_VALUE.ordinal());
+        pathBuilder.addAttribute(
+            NormalizedNodeMessages.PathArgumentAttribute.newBuilder()
+                .setValue("foo").setType(ValueType.STRING_TYPE.ordinal()));
+
+        nodeBuilder.addCode(TestModel.TEST_QNAME.getNamespace().toString());
+        nodeBuilder.addCode(TestModel.TEST_QNAME.getFormattedRevision());
+        nodeBuilder.addCode(TestModel.TEST_QNAME.getLocalName());
+
+        YangInstanceIdentifier.PathArgument pathArgument =
+            NormalizedNodeSerializer
+                .deSerialize(nodeBuilder.build(), pathBuilder.build());
+
+        assertEquals(new YangInstanceIdentifier.NodeWithValue(TestModel.TEST_QNAME, "foo"), pathArgument);
+
+    }
+    @Test
+    public void testDeSerializeNodeIdentifierWithPredicates(){
+        NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
+        NormalizedNodeMessages.PathArgument.Builder pathBuilder = NormalizedNodeMessages.PathArgument.newBuilder();
+        NormalizedNodeMessages.QName.Builder qNameBuilder = NormalizedNodeMessages.QName.newBuilder();
+
+        qNameBuilder.setNamespace(0);
+        qNameBuilder.setRevision(1);
+        qNameBuilder.setLocalName(2);
+
+        pathBuilder.setNodeType(qNameBuilder);
+        pathBuilder.setIntType(PathArgumentType.NODE_IDENTIFIER_WITH_PREDICATES.ordinal());
+        pathBuilder.addAttribute(NormalizedNodeMessages.PathArgumentAttribute.newBuilder().setName(qNameBuilder).setValue(
+            "foo").setType(ValueType.STRING_TYPE.ordinal()));
+
+        nodeBuilder.addCode(TestModel.TEST_QNAME.getNamespace().toString());
+        nodeBuilder.addCode(TestModel.TEST_QNAME.getFormattedRevision());
+        nodeBuilder.addCode(TestModel.TEST_QNAME.getLocalName());
+
+        YangInstanceIdentifier.PathArgument pathArgument =
+            NormalizedNodeSerializer
+                .deSerialize(nodeBuilder.build(), pathBuilder.build());
+
+        assertEquals(new YangInstanceIdentifier.NodeIdentifierWithPredicates(TestModel.TEST_QNAME,
+            ImmutableMap.<QName, Object>of(TestModel.TEST_QNAME, "foo")), pathArgument);
+
+    }
+    @Test
+    public void testDeSerializeNodeAugmentationIdentifier(){
+        NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
+        NormalizedNodeMessages.PathArgument.Builder pathBuilder = NormalizedNodeMessages.PathArgument.newBuilder();
+        NormalizedNodeMessages.QName.Builder qNameBuilder = NormalizedNodeMessages.QName.newBuilder();
+
+        qNameBuilder.setNamespace(0);
+        qNameBuilder.setRevision(1);
+        qNameBuilder.setLocalName(2);
+
+        pathBuilder.setIntType(PathArgumentType.AUGMENTATION_IDENTIFIER.ordinal());
+        pathBuilder.addAttribute(NormalizedNodeMessages.PathArgumentAttribute.newBuilder().setName(qNameBuilder).setType(ValueType.STRING_TYPE.ordinal()));
+
+        nodeBuilder.addCode(TestModel.TEST_QNAME.getNamespace().toString());
+        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);
+
+    }
+
+
+
+}
diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/ValueSerializerTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/ValueSerializerTest.java
new file mode 100644 (file)
index 0000000..af7a385
--- /dev/null
@@ -0,0 +1,449 @@
+package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import org.junit.Rule;
+import org.junit.Test;
+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.yangtools.yang.data.api.YangInstanceIdentifier;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+
+public class ValueSerializerTest{
+
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Test
+    public void testSerializeShort(){
+        short v1 = 5;
+        NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
+        ValueSerializer.serialize(builder, mock(NormalizedNodeSerializationContext.class), v1);
+
+        assertEquals(ValueType.SHORT_TYPE.ordinal(), builder.getIntValueType());
+        assertEquals("5", builder.getValue());
+
+        NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
+
+        ValueSerializer.serialize(builder1, mock(NormalizedNodeSerializationContext.class), v1);
+
+        assertEquals(ValueType.SHORT_TYPE.ordinal(), builder1.getType());
+        assertEquals("5", builder.getValue());
+
+    }
+
+    @Test
+    public void testSerializeInteger(){
+        String hexNumber = "f3";
+
+        Integer expected = Integer.valueOf(hexNumber, 16);
+
+
+        NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
+        ValueSerializer.serialize(builder, mock(
+            NormalizedNodeSerializationContext.class), expected);
+
+        assertEquals(ValueType.INT_TYPE.ordinal(), builder.getIntValueType());
+        assertEquals("243", builder.getValue());
+
+        NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
+
+        ValueSerializer.serialize(builder1, mock(
+            NormalizedNodeSerializationContext.class), expected);
+
+        assertEquals(ValueType.INT_TYPE.ordinal(), builder1.getType());
+        assertEquals("243", builder1.getValue());
+
+
+    }
+
+
+    @Test
+    public void testSerializeLong(){
+        long v1 = 5;
+        NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
+        ValueSerializer.serialize(builder, mock(
+            NormalizedNodeSerializationContext.class), v1);
+
+        assertEquals(ValueType.LONG_TYPE.ordinal(), builder.getIntValueType());
+        assertEquals("5", builder.getValue());
+
+        NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
+
+        ValueSerializer.serialize(builder1, mock(
+            NormalizedNodeSerializationContext.class), v1);
+
+        assertEquals(ValueType.LONG_TYPE.ordinal(), builder1.getType());
+        assertEquals("5", builder1.getValue());
+
+    }
+
+    @Test
+    public void testSerializeByte(){
+        byte v1 = 5;
+        NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
+        ValueSerializer.serialize(builder, mock(
+            NormalizedNodeSerializationContext.class), v1);
+
+        assertEquals(ValueType.BYTE_TYPE.ordinal(), builder.getIntValueType());
+        assertEquals("5", builder.getValue());
+
+        NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
+
+        ValueSerializer.serialize(builder1, mock(
+            NormalizedNodeSerializationContext.class), v1);
+
+        assertEquals(ValueType.BYTE_TYPE.ordinal(), builder1.getType());
+        assertEquals("5", builder1.getValue());
+
+    }
+
+    @Test
+    public void testSerializeBits(){
+        NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
+        ValueSerializer.serialize(builder, mock(
+            NormalizedNodeSerializationContext.class),
+            ImmutableSet.of("foo", "bar"));
+
+        assertEquals(ValueType.BITS_TYPE.ordinal(), builder.getIntValueType());
+        assertTrue( "foo not in bits", builder.getBitsValueList().contains("foo"));
+        assertTrue( "bar not in bits", builder.getBitsValueList().contains("bar"));
+
+        NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
+
+        ValueSerializer.serialize(builder1, mock(
+            NormalizedNodeSerializationContext.class),
+            ImmutableSet.of("foo", "bar"));
+
+        assertEquals(ValueType.BITS_TYPE.ordinal(), builder1.getType());
+        assertEquals("[foo, bar]", builder1.getValue());
+
+    }
+
+    @Test
+    public void testSerializeWrongTypeOfSet(){
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Expected value type to be Bits but was :");
+        NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
+        ValueSerializer.serialize(builder, mock(
+                NormalizedNodeSerializationContext.class),
+            ImmutableSet.of(1, 2));
+
+    }
+
+    @Test
+    public void testSerializeEmptyString(){
+        NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
+        ValueSerializer.serialize(builder, mock(
+            NormalizedNodeSerializationContext.class),"");
+
+        assertEquals(ValueType.STRING_TYPE.ordinal(), builder.getIntValueType());
+        assertEquals("", builder.getValue());
+
+        NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
+
+        ValueSerializer.serialize(builder1, mock(
+            NormalizedNodeSerializationContext.class),"");
+
+        assertEquals(ValueType.STRING_TYPE.ordinal(), builder1.getType());
+        assertEquals("", builder1.getValue());
+
+    }
+
+    @Test
+    public void testSerializeString(){
+        NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
+        ValueSerializer.serialize(builder, mock(
+            NormalizedNodeSerializationContext.class),"foo");
+
+        assertEquals(ValueType.STRING_TYPE.ordinal(), builder.getIntValueType());
+        assertEquals("foo", builder.getValue());
+
+        NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
+
+        ValueSerializer.serialize(builder1, mock(
+            NormalizedNodeSerializationContext.class),"foo");
+
+        assertEquals(ValueType.STRING_TYPE.ordinal(), builder1.getType());
+        assertEquals("foo", builder1.getValue());
+
+    }
+
+
+    @Test
+    public void testSerializeBoolean(){
+        boolean v1 = true;
+        NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
+        ValueSerializer.serialize(builder, mock(
+            NormalizedNodeSerializationContext.class), v1);
+
+        assertEquals(ValueType.BOOL_TYPE.ordinal(), builder.getIntValueType());
+        assertEquals("true", builder.getValue());
+
+        NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
+        ValueSerializer.serialize(builder1, mock(
+            NormalizedNodeSerializationContext.class), v1);
+
+        assertEquals(ValueType.BOOL_TYPE.ordinal(), builder1.getType());
+        assertEquals("true", builder1.getValue());
+    }
+
+    @Test
+    public void testSerializeQName(){
+        QName v1 = TestModel.TEST_QNAME;
+        NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
+        ValueSerializer.serialize(builder, mock(
+            NormalizedNodeSerializationContext.class), v1);
+
+        assertEquals(ValueType.QNAME_TYPE.ordinal(), builder.getIntValueType());
+        assertEquals("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test", builder.getValue());
+
+        NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
+
+        ValueSerializer.serialize(builder1, mock(
+            NormalizedNodeSerializationContext.class), v1);
+
+        assertEquals(ValueType.QNAME_TYPE.ordinal(), builder1.getType());
+        assertEquals("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test", builder1.getValue());
+
+    }
+
+    @Test
+    public void testSerializeYangIdentifier(){
+        YangInstanceIdentifier v1 = TestModel.TEST_PATH;
+
+        NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
+        ValueSerializer.serialize(builder, mock(
+            NormalizedNodeSerializationContext.class), v1);
+
+
+        assertEquals(ValueType.YANG_IDENTIFIER_TYPE.ordinal(), builder.getIntValueType());
+        NormalizedNodeMessages.InstanceIdentifier serializedYangInstanceIdentifier =
+            builder.getInstanceIdentifierValue();
+
+        assertEquals(1, serializedYangInstanceIdentifier.getArgumentsCount());
+        assertEquals(TestModel.TEST_QNAME.toString(), serializedYangInstanceIdentifier.getArguments(0).getNodeType().getValue());
+    }
+
+    @Test
+    public void testSerializeBigInteger(){
+        BigInteger v1 = new BigInteger("1000000000000000000000000");
+        NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
+        ValueSerializer.serialize(builder, mock(
+            NormalizedNodeSerializationContext.class), v1);