X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-clustering-commons%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2Fnode%2Futils%2Fstream%2FNormalizedNodeInputStreamReader.java;h=9b2ce2b64d4fab9d71e5ac844983008ad8b85979;hp=428a578e808950a0d445708be7b74579529f65ed;hb=a69604185f71923bdfc16d2d056490fff9a8d90e;hpb=315a23ea8d215ac5b29fea613f31fd35f6a6899b;ds=sidebyside 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 428a578e80..9b2ce2b64d 100755 --- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeInputStreamReader.java +++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeInputStreamReader.java @@ -5,10 +5,10 @@ * 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.stream; -import com.google.common.base.Preconditions; +import static java.util.Objects.requireNonNull; + import com.google.common.base.Strings; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableList.Builder; @@ -18,9 +18,9 @@ import java.io.StringReader; import java.math.BigDecimal; import java.math.BigInteger; import java.nio.charset.StandardCharsets; -import java.util.HashMap; +import java.util.ArrayList; import java.util.HashSet; -import java.util.Map; +import java.util.List; import java.util.Set; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; @@ -30,6 +30,7 @@ import org.opendaylight.yangtools.util.ImmutableOffsetMapTemplate; import org.opendaylight.yangtools.yang.common.Empty; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue; @@ -39,7 +40,7 @@ import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.impl.schema.Builders; 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.NormalizedNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder; import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.slf4j.Logger; @@ -57,26 +58,21 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput private static final Logger LOG = LoggerFactory.getLogger(NormalizedNodeInputStreamReader.class); - private static final String REVISION_ARG = "?revision="; - private final DataInput input; - private final Map codedStringMap = new HashMap<>(); + private final List codedStringMap = new ArrayList<>(); private QName lastLeafSetQName; - private NormalizedNodeAttrBuilder> leafBuilder; + private NormalizedNodeBuilder> leafBuilder; @SuppressWarnings("rawtypes") - private NormalizedNodeAttrBuilder> leafSetEntryBuilder; - - private final StringBuilder reusableStringBuilder = new StringBuilder(50); + private NormalizedNodeBuilder> leafSetEntryBuilder; private boolean readSignatureMarker = true; NormalizedNodeInputStreamReader(final DataInput input, final boolean versionChecked) { - this.input = Preconditions.checkNotNull(input); + this.input = requireNonNull(input); readSignatureMarker = !versionChecked; } @@ -114,43 +110,31 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput } switch (nodeType) { - case NodeTypes.AUGMENTATION_NODE : - YangInstanceIdentifier.AugmentationIdentifier augIdentifier = - new YangInstanceIdentifier.AugmentationIdentifier(readQNameSet()); - + case NodeTypes.AUGMENTATION_NODE: + AugmentationIdentifier augIdentifier = readAugmentationIdentifier(); LOG.trace("Reading augmentation node {} ", augIdentifier); + return addDataContainerChildren(Builders.augmentationBuilder().withNodeIdentifier(augIdentifier)) + .build(); - return addDataContainerChildren(Builders.augmentationBuilder() - .withNodeIdentifier(augIdentifier)).build(); - - case NodeTypes.LEAF_SET_ENTRY_NODE : - QName name = lastLeafSetQName; - if (name == null) { - name = readQName(); - } - - Object value = readObject(); - NodeWithValue leafIdentifier = new NodeWithValue<>(name, value); - + case NodeTypes.LEAF_SET_ENTRY_NODE: + final QName name = lastLeafSetQName != null ? lastLeafSetQName : readQName(); + final Object value = readObject(); + final NodeWithValue leafIdentifier = new NodeWithValue<>(name, value); LOG.trace("Reading leaf set entry node {}, value {}", leafIdentifier, value); - return leafSetEntryBuilder().withNodeIdentifier(leafIdentifier).withValue(value).build(); - case NodeTypes.MAP_ENTRY_NODE : - NodeIdentifierWithPredicates entryIdentifier = readNormalizedNodeWithPredicates(); - + case NodeTypes.MAP_ENTRY_NODE: + final NodeIdentifierWithPredicates entryIdentifier = readNormalizedNodeWithPredicates(); LOG.trace("Reading map entry node {} ", entryIdentifier); + return addDataContainerChildren(Builders.mapEntryBuilder().withNodeIdentifier(entryIdentifier)) + .build(); - return addDataContainerChildren(Builders.mapEntryBuilder() - .withNodeIdentifier(entryIdentifier)).build(); - - default : - return readNodeIdentifierDependentNode(nodeType, new NodeIdentifier(readQName())); + default: + return readNodeIdentifierDependentNode(nodeType, readNodeIdentifier()); } } - private NormalizedNodeAttrBuilder> leafBuilder() { + private NormalizedNodeBuilder> leafBuilder() { if (leafBuilder == null) { leafBuilder = Builders.leafBuilder(); } @@ -159,8 +143,7 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput } @SuppressWarnings("rawtypes") - private NormalizedNodeAttrBuilder> leafSetEntryBuilder() { + private NormalizedNodeBuilder> leafSetEntryBuilder() { if (leafSetEntryBuilder == null) { leafSetEntryBuilder = Builders.leafSetEntryBuilder(); } @@ -172,16 +155,16 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput throws IOException { switch (nodeType) { - case NodeTypes.LEAF_NODE : + case NodeTypes.LEAF_NODE: LOG.trace("Read leaf node {}", identifier); // Read the object value return leafBuilder().withNodeIdentifier(identifier).withValue(readObject()).build(); - case NodeTypes.ANY_XML_NODE : + case NodeTypes.ANY_XML_NODE: LOG.trace("Read xml node"); return Builders.anyXmlBuilder().withNodeIdentifier(identifier).withValue(readDOMSource()).build(); - case NodeTypes.MAP_NODE : + case NodeTypes.MAP_NODE: LOG.trace("Read map node {}", identifier); return addDataContainerChildren(Builders.mapBuilder().withNodeIdentifier(identifier)).build(); @@ -206,7 +189,7 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput LOG.trace("Read container node {}", identifier); return addDataContainerChildren(Builders.containerBuilder().withNodeIdentifier(identifier)).build(); - case NodeTypes.LEAF_SET : + case NodeTypes.LEAF_SET: LOG.trace("Read leaf set node {}", identifier); return addLeafSetChildren(identifier.getNodeType(), Builders.leafSetBuilder().withNodeIdentifier(identifier)).build(); @@ -238,32 +221,31 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput // Read in the same sequence of writing String localName = readCodedString(); String namespace = readCodedString(); - String revision = readCodedString(); - - String qname; - if (!Strings.isNullOrEmpty(revision)) { - qname = reusableStringBuilder.append('(').append(namespace).append(REVISION_ARG).append(revision) - .append(')').append(localName).toString(); - } else { - qname = reusableStringBuilder.append('(').append(namespace).append(')').append(localName).toString(); - } + String revision = Strings.emptyToNull(readCodedString()); - reusableStringBuilder.delete(0, reusableStringBuilder.length()); - return QNameFactory.create(qname); + return QNameFactory.create(new QNameFactory.Key(localName, namespace, revision)); } private String readCodedString() throws IOException { - byte valueType = input.readByte(); - if (valueType == TokenTypes.IS_CODE_VALUE) { - return codedStringMap.get(input.readInt()); - } else if (valueType == TokenTypes.IS_STRING_VALUE) { - String value = input.readUTF().intern(); - codedStringMap.put(codedStringMap.size(), value); - return value; + final byte valueType = input.readByte(); + switch (valueType) { + case TokenTypes.IS_NULL_VALUE: + return null; + case TokenTypes.IS_CODE_VALUE: + final int code = input.readInt(); + try { + return codedStringMap.get(code); + } catch (IndexOutOfBoundsException e) { + throw new IOException("String code " + code + " was not found", e); + } + case TokenTypes.IS_STRING_VALUE: + final String value = input.readUTF().intern(); + codedStringMap.add(value); + return value; + default: + throw new IOException("Unhandled string value type " + valueType); } - - return null; } private Set readQNameSet() throws IOException { @@ -276,6 +258,16 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput return children; } + private AugmentationIdentifier readAugmentationIdentifier() throws IOException { + // FIXME: we should have a cache for these, too + return new AugmentationIdentifier(readQNameSet()); + } + + private NodeIdentifier readNodeIdentifier() throws IOException { + // FIXME: we should have a cache for these, too + return new NodeIdentifier(readQName()); + } + private NodeIdentifierWithPredicates readNormalizedNodeWithPredicates() throws IOException { final QName qname = readQName(); final int count = input.readInt(); @@ -304,42 +296,42 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput case ValueTypes.BITS_TYPE: return readObjSet(); - case ValueTypes.BOOL_TYPE : + case ValueTypes.BOOL_TYPE: return input.readBoolean(); - case ValueTypes.BYTE_TYPE : + case ValueTypes.BYTE_TYPE: return input.readByte(); - case ValueTypes.INT_TYPE : + case ValueTypes.INT_TYPE: return input.readInt(); - case ValueTypes.LONG_TYPE : + case ValueTypes.LONG_TYPE: return input.readLong(); - case ValueTypes.QNAME_TYPE : + case ValueTypes.QNAME_TYPE: return readQName(); - case ValueTypes.SHORT_TYPE : + case ValueTypes.SHORT_TYPE: return input.readShort(); - case ValueTypes.STRING_TYPE : + case ValueTypes.STRING_TYPE: return input.readUTF(); case ValueTypes.STRING_BYTES_TYPE: return readStringBytes(); - case ValueTypes.BIG_DECIMAL_TYPE : + case ValueTypes.BIG_DECIMAL_TYPE: return new BigDecimal(input.readUTF()); - case ValueTypes.BIG_INTEGER_TYPE : + case ValueTypes.BIG_INTEGER_TYPE: return new BigInteger(input.readUTF()); - case ValueTypes.BINARY_TYPE : + case ValueTypes.BINARY_TYPE: byte[] bytes = new byte[input.readInt()]; input.readFully(bytes); return bytes; - case ValueTypes.YANG_IDENTIFIER_TYPE : + case ValueTypes.YANG_IDENTIFIER_TYPE: return readYangInstanceIdentifierInternal(); case ValueTypes.EMPTY_TYPE: @@ -351,7 +343,7 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput case ValueTypes.NULL_TYPE: return Empty.getInstance(); - default : + default: return null; } } @@ -406,20 +398,16 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput int type = input.readByte(); switch (type) { - - case PathArgumentTypes.AUGMENTATION_IDENTIFIER : - return new YangInstanceIdentifier.AugmentationIdentifier(readQNameSet()); - - case PathArgumentTypes.NODE_IDENTIFIER : - return new NodeIdentifier(readQName()); - - case PathArgumentTypes.NODE_IDENTIFIER_WITH_PREDICATES : + case PathArgumentTypes.AUGMENTATION_IDENTIFIER: + return readAugmentationIdentifier(); + case PathArgumentTypes.NODE_IDENTIFIER: + return readNodeIdentifier(); + case PathArgumentTypes.NODE_IDENTIFIER_WITH_PREDICATES: return readNormalizedNodeWithPredicates(); - - case PathArgumentTypes.NODE_IDENTIFIER_WITH_VALUE : + case PathArgumentTypes.NODE_IDENTIFIER_WITH_VALUE: return new NodeWithValue<>(readQName(), readObject()); - - default : + default: + // FIXME: throw hard error return null; } }