From: Moiz Raja Date: Wed, 26 Nov 2014 18:34:42 +0000 (+0000) Subject: Merge "Bug 2267: Reuse leaf and leaf set entry builders in NormalizedNodeInputStreamR... X-Git-Tag: release/lithium~835 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=commitdiff_plain;h=d70f418d19fa09b1efc8fa4ce4ed35f0cf59b73b;hp=ecd49a2e11021576f51052ad54f785c9b0e65122 Merge "Bug 2267: Reuse leaf and leaf set entry builders in NormalizedNodeInputStreamReader" --- diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeInputStreamReader.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeInputStreamReader.java index 797258b443..9201a94de3 100644 --- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeInputStreamReader.java +++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeInputStreamReader.java @@ -11,29 +11,25 @@ package org.opendaylight.controller.cluster.datastore.node.utils.stream; import com.google.common.base.Preconditions; +import com.google.common.base.Strings; import org.opendaylight.controller.cluster.datastore.node.utils.QNameFactory; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.Node; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; -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.YangInstanceIdentifier.NodeIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; +import org.opendaylight.yangtools.yang.data.api.schema.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 org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.io.DataInput; import java.io.DataInputStream; import java.io.IOException; import java.io.InputStream; @@ -59,141 +55,135 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead private static final String REVISION_ARG = "?revision="; - private final DataInputStream reader; + private final DataInput input; private final Map codedStringMap = new HashMap<>(); private QName lastLeafSetQName; + private NormalizedNodeAttrBuilder> leafBuilder; + + private NormalizedNodeAttrBuilder> leafSetEntryBuilder; + public NormalizedNodeInputStreamReader(InputStream stream) throws IOException { Preconditions.checkNotNull(stream); - reader = new DataInputStream(stream); + input = new DataInputStream(stream); + } + + public NormalizedNodeInputStreamReader(DataInput input) throws IOException { + this.input = Preconditions.checkNotNull(input); } @Override public NormalizedNode readNormalizedNode() throws IOException { - NormalizedNode node = null; - // each node should start with a byte - byte nodeType = reader.readByte(); + byte nodeType = input.readByte(); if(nodeType == NodeTypes.END_NODE) { LOG.debug("End node reached. return"); return null; } - else if(nodeType == NodeTypes.AUGMENTATION_NODE) { - LOG.debug("Reading augmentation node. will create augmentation identifier"); - YangInstanceIdentifier.AugmentationIdentifier identifier = - new YangInstanceIdentifier.AugmentationIdentifier(readQNameSet()); - DataContainerNodeBuilder augmentationBuilder = - Builders.augmentationBuilder().withNodeIdentifier(identifier); - augmentationBuilder = addDataContainerChildren(augmentationBuilder); - node = augmentationBuilder.build(); + switch(nodeType) { + case NodeTypes.AUGMENTATION_NODE : + YangInstanceIdentifier.AugmentationIdentifier augIdentifier = + new YangInstanceIdentifier.AugmentationIdentifier(readQNameSet()); - } else { - if(nodeType == NodeTypes.LEAF_SET_ENTRY_NODE) { - LOG.debug("Reading leaf set entry node. Will create NodeWithValue instance identifier"); + LOG.debug("Reading augmentation node {} ", augIdentifier); - // Read the object value + return addDataContainerChildren(Builders.augmentationBuilder(). + withNodeIdentifier(augIdentifier)).build(); + + case NodeTypes.LEAF_SET_ENTRY_NODE : Object value = readObject(); + NodeWithValue leafIdentifier = new NodeWithValue(lastLeafSetQName, value); + + LOG.debug("Reading leaf set entry node {}, value {}", leafIdentifier, value); + + return leafSetEntryBuilder().withNodeIdentifier(leafIdentifier).withValue(value).build(); - YangInstanceIdentifier.NodeWithValue nodeWithValue = new YangInstanceIdentifier.NodeWithValue( - lastLeafSetQName, value); - node = Builders.leafSetEntryBuilder().withNodeIdentifier(nodeWithValue). - withValue(value).build(); + case NodeTypes.MAP_ENTRY_NODE : + NodeIdentifierWithPredicates entryIdentifier = new NodeIdentifierWithPredicates( + readQName(), readKeyValueMap()); - } else if(nodeType == NodeTypes.MAP_ENTRY_NODE) { - LOG.debug("Reading map entry node. Will create node identifier with predicates."); + LOG.debug("Reading map entry node {} ", entryIdentifier); - QName qName = readQName(); - YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifier = - new YangInstanceIdentifier.NodeIdentifierWithPredicates(qName, readKeyValueMap()); - DataContainerNodeAttrBuilder mapEntryBuilder - = Builders.mapEntryBuilder().withNodeIdentifier(nodeIdentifier); + return addDataContainerChildren(Builders.mapEntryBuilder(). + withNodeIdentifier(entryIdentifier)).build(); - mapEntryBuilder = (DataContainerNodeAttrBuilder)addDataContainerChildren(mapEntryBuilder); - node = mapEntryBuilder.build(); + default : + return readNodeIdentifierDependentNode(nodeType, new NodeIdentifier(readQName())); + } + } - } else { - LOG.debug("Creating standard node identifier. "); + private NormalizedNodeAttrBuilder> leafBuilder() { + if(leafBuilder == null) { + leafBuilder = Builders.leafBuilder(); + } - QName qName = readQName(); - YangInstanceIdentifier.NodeIdentifier identifier = new YangInstanceIdentifier.NodeIdentifier(qName); - node = readNodeIdentifierDependentNode(nodeType, identifier); + return leafBuilder; + } - } + private NormalizedNodeAttrBuilder> leafSetEntryBuilder() { + if(leafSetEntryBuilder == null) { + leafSetEntryBuilder = Builders.leafSetEntryBuilder(); } - return node; + + return leafSetEntryBuilder; } - private NormalizedNode readNodeIdentifierDependentNode(byte nodeType, YangInstanceIdentifier.NodeIdentifier identifier) + private NormalizedNode readNodeIdentifierDependentNode(byte nodeType, NodeIdentifier identifier) throws IOException { switch(nodeType) { case NodeTypes.LEAF_NODE : - LOG.debug("Read leaf node"); + LOG.debug("Read leaf node {}", identifier); // Read the object value - NormalizedNodeAttrBuilder leafBuilder = Builders.leafBuilder(); - return leafBuilder.withNodeIdentifier(identifier).withValue(readObject()).build(); + return leafBuilder().withNodeIdentifier(identifier).withValue(readObject()).build(); case NodeTypes.ANY_XML_NODE : LOG.debug("Read xml node"); Node value = (Node) readObject(); - return Builders.anyXmlBuilder().withValue(value).build(); + return Builders.anyXmlBuilder().withValue((Node) readObject()).build(); case NodeTypes.MAP_NODE : - LOG.debug("Read map node"); - CollectionNodeBuilder mapBuilder = Builders.mapBuilder().withNodeIdentifier(identifier); - mapBuilder = addMapNodeChildren(mapBuilder); - return mapBuilder.build(); + LOG.debug("Read map node {}", identifier); + return addDataContainerChildren(Builders.mapBuilder(). + withNodeIdentifier(identifier)).build(); case NodeTypes.CHOICE_NODE : - LOG.debug("Read choice node"); - DataContainerNodeBuilder choiceBuilder = - Builders.choiceBuilder().withNodeIdentifier(identifier); - choiceBuilder = addDataContainerChildren(choiceBuilder); - return choiceBuilder.build(); + LOG.debug("Read choice node {}", identifier); + return addDataContainerChildren(Builders.choiceBuilder(). + withNodeIdentifier(identifier)).build(); case NodeTypes.ORDERED_MAP_NODE : - LOG.debug("Reading ordered map node"); - CollectionNodeBuilder orderedMapBuilder = - Builders.orderedMapBuilder().withNodeIdentifier(identifier); - orderedMapBuilder = addMapNodeChildren(orderedMapBuilder); - return orderedMapBuilder.build(); + LOG.debug("Reading ordered map node {}", identifier); + return addDataContainerChildren(Builders.orderedMapBuilder(). + withNodeIdentifier(identifier)).build(); case NodeTypes.UNKEYED_LIST : - LOG.debug("Read unkeyed list node"); - CollectionNodeBuilder unkeyedListBuilder = - Builders.unkeyedListBuilder().withNodeIdentifier(identifier); - unkeyedListBuilder = addUnkeyedListChildren(unkeyedListBuilder); - return unkeyedListBuilder.build(); + LOG.debug("Read unkeyed list node {}", identifier); + return addDataContainerChildren(Builders.unkeyedListBuilder(). + withNodeIdentifier(identifier)).build(); case NodeTypes.UNKEYED_LIST_ITEM : - LOG.debug("Read unkeyed list item node"); - DataContainerNodeAttrBuilder unkeyedListEntryBuilder - = Builders.unkeyedListEntryBuilder().withNodeIdentifier(identifier); - - unkeyedListEntryBuilder = (DataContainerNodeAttrBuilder) - addDataContainerChildren(unkeyedListEntryBuilder); - return unkeyedListEntryBuilder.build(); + LOG.debug("Read unkeyed list item node {}", identifier); + return addDataContainerChildren(Builders.unkeyedListEntryBuilder(). + withNodeIdentifier(identifier)).build(); case NodeTypes.CONTAINER_NODE : - LOG.debug("Read container node"); - DataContainerNodeAttrBuilder containerBuilder = - Builders.containerBuilder().withNodeIdentifier(identifier); - - containerBuilder = (DataContainerNodeAttrBuilder) - addDataContainerChildren(containerBuilder); - return containerBuilder.build(); + LOG.debug("Read container node {}", identifier); + return addDataContainerChildren(Builders.containerBuilder(). + withNodeIdentifier(identifier)).build(); case NodeTypes.LEAF_SET : - LOG.debug("Read leaf set node"); - ListNodeBuilder> leafSetBuilder = - Builders.leafSetBuilder().withNodeIdentifier(identifier); - leafSetBuilder = addLeafSetChildren(identifier.getNodeType(), leafSetBuilder); - return leafSetBuilder.build(); + LOG.debug("Read leaf set node {}", identifier); + return addLeafSetChildren(identifier.getNodeType(), + Builders.leafSetBuilder().withNodeIdentifier(identifier)).build(); default : return null; @@ -205,12 +195,13 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead String localName = readCodedString(); String namespace = readCodedString(); String revision = readCodedString(); - String qName; + // Not using stringbuilder as compiler optimizes string concatenation of + - if(revision != null){ - qName = "(" + namespace+ REVISION_ARG + revision + ")" +localName; + String qName; + if(!Strings.isNullOrEmpty(revision)) { + qName = "(" + namespace + REVISION_ARG + revision + ")" +localName; } else { - qName = "(" + namespace + ")" +localName; + qName = "(" + namespace + ")" + localName; } return QNameFactory.create(qName); @@ -218,33 +209,33 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead private String readCodedString() throws IOException { - boolean readFromMap = reader.readBoolean(); - if(readFromMap) { - return codedStringMap.get(reader.readInt()); - } else { - String value = reader.readUTF(); - if(value != null) { - codedStringMap.put(Integer.valueOf(codedStringMap.size()), value); - } + byte valueType = input.readByte(); + if(valueType == NormalizedNodeOutputStreamWriter.IS_CODE_VALUE) { + return codedStringMap.get(input.readInt()); + } else if(valueType == NormalizedNodeOutputStreamWriter.IS_STRING_VALUE) { + String value = input.readUTF(); + codedStringMap.put(Integer.valueOf(codedStringMap.size()), value); return value; } + + return null; } private Set readQNameSet() throws IOException{ // Read the children count - int count = reader.readInt(); + int count = input.readInt(); Set children = new HashSet<>(count); - for(int i = 0; i readKeyValueMap() throws IOException { - int count = reader.readInt(); + int count = input.readInt(); Map keyValueMap = new HashMap<>(count); - for(int i = 0; i pathArguments = new ArrayList<>(size); - - for(int i=0; i pathArguments = new ArrayList<>(size); + + for(int i = 0; i < size; i++) { + pathArguments.add(readPathArgument()); + } + return YangInstanceIdentifier.create(pathArguments); + } + private Set readObjSet() throws IOException { - int count = reader.readInt(); + int count = input.readInt(); Set children = new HashSet<>(count); - for(int i = 0; i> addLeafSetChildren(QName nodeType, - ListNodeBuilder> builder) - throws IOException { + ListNodeBuilder> builder) throws IOException { LOG.debug("Reading children of leaf set"); @@ -348,53 +343,17 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead return builder; } - private CollectionNodeBuilder addUnkeyedListChildren( - CollectionNodeBuilder builder) - throws IOException{ - - LOG.debug("Reading children of unkeyed list"); - UnkeyedListEntryNode child = (UnkeyedListEntryNode)readNormalizedNode(); - - while(child != null) { - builder.withChild(child); - child = (UnkeyedListEntryNode)readNormalizedNode(); - } - return builder; - } - - private DataContainerNodeBuilder addDataContainerChildren(DataContainerNodeBuilder builder) - throws IOException { + @SuppressWarnings({ "unchecked", "rawtypes" }) + private NormalizedNodeContainerBuilder addDataContainerChildren( + NormalizedNodeContainerBuilder builder) throws IOException { LOG.debug("Reading data container (leaf nodes) nodes"); - DataContainerChild child = - (DataContainerChild) readNormalizedNode(); + NormalizedNode child = readNormalizedNode(); while(child != null) { - builder.withChild(child); - child = - (DataContainerChild) readNormalizedNode(); + builder.addChild(child); + child = readNormalizedNode(); } return builder; } - - - private CollectionNodeBuilder addMapNodeChildren(CollectionNodeBuilder builder) - throws IOException { - LOG.debug("Reading map node children"); - MapEntryNode child = (MapEntryNode)readNormalizedNode(); - - while(child != null){ - builder.withChild(child); - child = (MapEntryNode)readNormalizedNode(); - } - - return builder; - } - - - @Override - public void close() throws IOException { - reader.close(); - } - } diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeOutputStreamWriter.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeOutputStreamWriter.java index 08567fd79e..46768d5112 100644 --- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeOutputStreamWriter.java +++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeOutputStreamWriter.java @@ -17,7 +17,7 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter; import org.slf4j.Logger; import org.slf4j.LoggerFactory; - +import java.io.DataOutput; import java.io.DataOutputStream; import java.io.IOException; import java.io.OutputStream; @@ -40,17 +40,25 @@ import java.util.Set; * */ -public class NormalizedNodeOutputStreamWriter implements NormalizedNodeStreamWriter{ +public class NormalizedNodeOutputStreamWriter implements NormalizedNodeStreamWriter { private static final Logger LOG = LoggerFactory.getLogger(NormalizedNodeOutputStreamWriter.class); - private final DataOutputStream writer; + static final byte IS_CODE_VALUE = 1; + static final byte IS_STRING_VALUE = 2; + static final byte IS_NULL_VALUE = 3; + + private final DataOutput output; private final Map stringCodeMap = new HashMap<>(); public NormalizedNodeOutputStreamWriter(OutputStream stream) throws IOException { Preconditions.checkNotNull(stream); - writer = new DataOutputStream(stream); + output = new DataOutputStream(stream); + } + + public NormalizedNodeOutputStreamWriter(DataOutput output) throws IOException { + this.output = Preconditions.checkNotNull(output); } @Override @@ -74,7 +82,7 @@ public class NormalizedNodeOutputStreamWriter implements NormalizedNodeStreamWri public void leafSetEntryNode(Object value) throws IOException, IllegalArgumentException { LOG.debug("Writing a new leaf set entry node"); - writer.writeByte(NodeTypes.LEAF_SET_ENTRY_NODE); + output.writeByte(NodeTypes.LEAF_SET_ENTRY_NODE); writeObject(value); } @@ -142,7 +150,7 @@ public class NormalizedNodeOutputStreamWriter implements NormalizedNodeStreamWri Preconditions.checkNotNull(identifier, "Node identifier should not be null"); LOG.debug("Starting a new augmentation node"); - writer.writeByte(NodeTypes.AUGMENTATION_NODE); + output.writeByte(NodeTypes.AUGMENTATION_NODE); writeQNameSet(identifier.getPossibleChildNames()); } @@ -160,24 +168,22 @@ public class NormalizedNodeOutputStreamWriter implements NormalizedNodeStreamWri public void endNode() throws IOException, IllegalStateException { LOG.debug("Ending the node"); - writer.writeByte(NodeTypes.END_NODE); + output.writeByte(NodeTypes.END_NODE); } @Override public void close() throws IOException { - writer.close(); } @Override public void flush() throws IOException { - writer.flush(); } private void startNode(final QName qName, byte nodeType) throws IOException { Preconditions.checkNotNull(qName, "QName of node identifier should not be null."); // First write the type of node - writer.writeByte(nodeType); + output.writeByte(nodeType); // Write Start Tag writeQName(qName); } @@ -191,22 +197,23 @@ public class NormalizedNodeOutputStreamWriter implements NormalizedNodeStreamWri private void writeCodedString(String key) throws IOException { Integer value = stringCodeMap.get(key); - if(value != null) { - writer.writeBoolean(true); - writer.writeInt(value); + output.writeByte(IS_CODE_VALUE); + output.writeInt(value); } else { if(key != null) { + output.writeByte(IS_STRING_VALUE); stringCodeMap.put(key, Integer.valueOf(stringCodeMap.size())); + output.writeUTF(key); + } else { + output.writeByte(IS_NULL_VALUE); } - writer.writeBoolean(false); - writer.writeUTF(key); } } private void writeObjSet(Set set) throws IOException { if(!set.isEmpty()){ - writer.writeInt(set.size()); + output.writeInt(set.size()); for(Object o : set){ if(o instanceof String){ writeCodedString(o.toString()); @@ -216,14 +223,14 @@ public class NormalizedNodeOutputStreamWriter implements NormalizedNodeStreamWri } } } else { - writer.writeInt(0); + output.writeInt(0); } } - private void writeYangInstanceIdentifier(YangInstanceIdentifier identifier) throws IOException { + public void writeYangInstanceIdentifier(YangInstanceIdentifier identifier) throws IOException { Iterable pathArguments = identifier.getPathArguments(); int size = Iterables.size(pathArguments); - writer.writeInt(size); + output.writeInt(size); for(YangInstanceIdentifier.PathArgument pathArgument : pathArguments) { writePathArgument(pathArgument); @@ -234,7 +241,7 @@ public class NormalizedNodeOutputStreamWriter implements NormalizedNodeStreamWri byte type = PathArgumentTypes.getSerializablePathArgumentType(pathArgument); - writer.writeByte(type); + output.writeByte(type); switch(type) { case PathArgumentTypes.NODE_IDENTIFIER : @@ -278,7 +285,7 @@ public class NormalizedNodeOutputStreamWriter implements NormalizedNodeStreamWri private void writeKeyValueMap(Map keyValueMap) throws IOException { if(keyValueMap != null && !keyValueMap.isEmpty()) { - writer.writeInt(keyValueMap.size()); + output.writeInt(keyValueMap.size()); Set qNameSet = keyValueMap.keySet(); for(QName qName : qNameSet) { @@ -286,47 +293,48 @@ public class NormalizedNodeOutputStreamWriter implements NormalizedNodeStreamWri writeObject(keyValueMap.get(qName)); } } else { - writer.writeInt(0); + output.writeInt(0); } } private void writeQNameSet(Set children) throws IOException { // Write each child's qname separately, if list is empty send count as 0 if(children != null && !children.isEmpty()) { - writer.writeInt(children.size()); + output.writeInt(children.size()); for(QName qName : children) { writeQName(qName); } } else { LOG.debug("augmentation node does not have any child"); - writer.writeInt(0); + output.writeInt(0); } } + @SuppressWarnings("rawtypes") private void writeObject(Object value) throws IOException { byte type = ValueTypes.getSerializableType(value); // Write object type first - writer.writeByte(type); + output.writeByte(type); switch(type) { case ValueTypes.BOOL_TYPE: - writer.writeBoolean((Boolean) value); + output.writeBoolean((Boolean) value); break; case ValueTypes.QNAME_TYPE: writeQName((QName) value); break; case ValueTypes.INT_TYPE: - writer.writeInt((Integer) value); + output.writeInt((Integer) value); break; case ValueTypes.BYTE_TYPE: - writer.writeByte((Byte) value); + output.writeByte((Byte) value); break; case ValueTypes.LONG_TYPE: - writer.writeLong((Long) value); + output.writeLong((Long) value); break; case ValueTypes.SHORT_TYPE: - writer.writeShort((Short) value); + output.writeShort((Short) value); break; case ValueTypes.BITS_TYPE: writeObjSet((Set) value); @@ -335,7 +343,7 @@ public class NormalizedNodeOutputStreamWriter implements NormalizedNodeStreamWri writeYangInstanceIdentifier((YangInstanceIdentifier) value); break; default: - writer.writeUTF(value.toString()); + output.writeUTF(value.toString()); break; } } diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeStreamReader.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeStreamReader.java index c619afd7ee..d2d5bf7c1d 100644 --- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeStreamReader.java +++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeStreamReader.java @@ -11,13 +11,13 @@ package org.opendaylight.controller.cluster.datastore.node.utils.stream; - -import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; - import java.io.IOException; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; - -public interface NormalizedNodeStreamReader extends AutoCloseable { +/** + * Interface for a class that can read serialized NormalizedNode instances from a stream. + */ +public interface NormalizedNodeStreamReader { NormalizedNode readNormalizedNode() throws IOException; } diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeStreamReaderWriterTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeStreamReaderWriterTest.java index ae548dba23..8854fc73b5 100644 --- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeStreamReaderWriterTest.java +++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeStreamReaderWriterTest.java @@ -7,29 +7,45 @@ * and is available at http://www.eclipse.org/legal/epl-v10.html * */ - package org.opendaylight.controller.cluster.datastore.node.utils.stream; - +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; import org.apache.commons.lang.SerializationUtils; import org.junit.Assert; import org.junit.Test; import org.opendaylight.controller.cluster.datastore.util.TestModel; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; -import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter; import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter; - -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.IOException; +import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter; +import org.opendaylight.yangtools.yang.data.impl.schema.Builders; +import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; public class NormalizedNodeStreamReaderWriterTest { - final NormalizedNode input = TestModel.createTestContainer(); - @Test public void testNormalizedNodeStreamReaderWriter() throws IOException { + testNormalizedNodeStreamReaderWriter(TestModel.createTestContainer()); + + QName toaster = QName.create("http://netconfcentral.org/ns/toaster","2009-11-20","toaster"); + QName darknessFactor = QName.create("http://netconfcentral.org/ns/toaster","2009-11-20","darknessFactor"); + ContainerNode toasterNode = Builders.containerBuilder(). + withNodeIdentifier(new NodeIdentifier(toaster)). + withChild(ImmutableNodes.leafNode(darknessFactor, "1000")).build(); + + testNormalizedNodeStreamReaderWriter(Builders.containerBuilder(). + withNodeIdentifier(new NodeIdentifier(SchemaContext.NAME)). + withChild(toasterNode).build()); + } + + private void testNormalizedNodeStreamReaderWriter(NormalizedNode input) throws IOException { + byte[] byteData = null; try(ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); @@ -41,22 +57,20 @@ public class NormalizedNodeStreamReaderWriterTest { } - try(NormalizedNodeInputStreamReader reader = new NormalizedNodeInputStreamReader( - new ByteArrayInputStream(byteData))) { - - NormalizedNode node = reader.readNormalizedNode(); - Assert.assertEquals(input, node); + NormalizedNodeInputStreamReader reader = new NormalizedNodeInputStreamReader( + new ByteArrayInputStream(byteData)); - } + NormalizedNode node = reader.readNormalizedNode(); + Assert.assertEquals(input, node); } @Test public void testWithSerializable() { - SampleNormalizedNodeSerializable serializable = new SampleNormalizedNodeSerializable(input); + NormalizedNode input = TestModel.createTestContainer(); + SampleNormalizedNodeSerializable serializable = new SampleNormalizedNodeSerializable(input ); SampleNormalizedNodeSerializable clone = (SampleNormalizedNodeSerializable)SerializationUtils.clone(serializable); Assert.assertEquals(input, clone.getInput()); } - } diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/SampleNormalizedNodeSerializable.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/SampleNormalizedNodeSerializable.java index 10a2ad90a5..6539015756 100644 --- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/SampleNormalizedNodeSerializable.java +++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/SampleNormalizedNodeSerializable.java @@ -8,16 +8,16 @@ package org.opendaylight.controller.cluster.datastore.node.utils.stream; - -import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; -import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter; -import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter; - +import java.io.DataInput; +import java.io.DataOutput; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; import java.net.URISyntaxException; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter; +import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter; public class SampleNormalizedNodeSerializable implements Serializable { private static final long serialVersionUID = 1L; @@ -33,12 +33,12 @@ public class SampleNormalizedNodeSerializable implements Serializable { } private void readObject(final ObjectInputStream stream) throws IOException, ClassNotFoundException, URISyntaxException { - NormalizedNodeStreamReader reader = new NormalizedNodeInputStreamReader(stream); + NormalizedNodeStreamReader reader = new NormalizedNodeInputStreamReader((DataInput)stream); this.input = reader.readNormalizedNode(); } private void writeObject(final ObjectOutputStream stream) throws IOException { - NormalizedNodeStreamWriter writer = new NormalizedNodeOutputStreamWriter(stream); + NormalizedNodeStreamWriter writer = new NormalizedNodeOutputStreamWriter((DataOutput)stream); NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(writer); normalizedNodeWriter.write(this.input);