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%2Ftransformer%2FNormalizedNodePruner.java;h=1577f0914706c75a874f8a68c94c6630a0a7fec9;hp=03fb6412b354100af5fbea756b62880324366a24;hb=f7d34eae1aa1938b98a05e8cf4b107b9933a5be5;hpb=561058be77594a026abbdbe82616fc65c7f58f48 diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePruner.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePruner.java index 03fb6412b3..1577f09147 100644 --- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePruner.java +++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePruner.java @@ -5,19 +5,22 @@ * 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.transformer; +import static com.google.common.base.Preconditions.checkState; + import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Optional; -import com.google.common.base.Preconditions; -import java.io.IOException; import java.net.URI; import java.util.LinkedList; import java.util.List; import javax.xml.transform.dom.DOMSource; 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; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode; import org.opendaylight.yangtools.yang.data.api.schema.LeafNode; @@ -33,37 +36,37 @@ import org.slf4j.LoggerFactory; /** * The NormalizedNodePruner removes all nodes from the input NormalizedNode that do not have a corresponding - * schema element in the passed in SchemaContext - * + * schema element in the passed in SchemaContext. */ public class NormalizedNodePruner implements NormalizedNodeStreamWriter { private static final Logger LOG = LoggerFactory.getLogger(NormalizedNodePruner.class); public static final URI BASE_NAMESPACE = URI.create("urn:ietf:params:xml:ns:netconf:base:1.0"); + private final SimpleStack stack = new SimpleStack<>(); - private NormalizedNode normalizedNode; private final DataSchemaContextNode nodePathSchemaNode; + + private NormalizedNode normalizedNode; private boolean sealed = false; - public NormalizedNodePruner(YangInstanceIdentifier nodePath, SchemaContext schemaContext) { + public NormalizedNodePruner(final YangInstanceIdentifier nodePath, final SchemaContext schemaContext) { nodePathSchemaNode = findSchemaNodeForNodePath(nodePath, schemaContext); } @SuppressWarnings("unchecked") @Override - public void leafNode(YangInstanceIdentifier.NodeIdentifier nodeIdentifier, Object o) throws IOException, IllegalArgumentException { - + public void leafNode(final NodeIdentifier nodeIdentifier, final Object value) { checkNotSealed(); NormalizedNodeBuilderWrapper parent = stack.peek(); - LeafNode leafNode = Builders.leafBuilder().withNodeIdentifier(nodeIdentifier).withValue(o).build(); - if(parent != null) { - if(hasValidSchema(nodeIdentifier.getNodeType(), parent)) { + LeafNode leafNode = Builders.leafBuilder().withNodeIdentifier(nodeIdentifier).withValue(value).build(); + if (parent != null) { + if (hasValidSchema(nodeIdentifier.getNodeType(), parent)) { parent.builder().addChild(leafNode); } } else { // If there's no parent node then this is a stand alone LeafNode. - if(nodePathSchemaNode != null) { + if (nodePathSchemaNode != null) { this.normalizedNode = leafNode; } @@ -72,37 +75,35 @@ public class NormalizedNodePruner implements NormalizedNodeStreamWriter { } @Override - public void startLeafSet(YangInstanceIdentifier.NodeIdentifier nodeIdentifier, int i) throws IOException, IllegalArgumentException { - + public void startLeafSet(final NodeIdentifier nodeIdentifier, final int count) { checkNotSealed(); - addBuilder(Builders.leafSetBuilder().withNodeIdentifier(nodeIdentifier), nodeIdentifier); } @Override - public void startOrderedLeafSet(YangInstanceIdentifier.NodeIdentifier nodeIdentifier, int i) throws IOException, IllegalArgumentException { - + public void startOrderedLeafSet(final NodeIdentifier nodeIdentifier, final int str) { checkNotSealed(); - addBuilder(Builders.orderedLeafSetBuilder().withNodeIdentifier(nodeIdentifier), nodeIdentifier); } - @SuppressWarnings({ "unchecked" }) + @SuppressWarnings("unchecked") @Override - public void leafSetEntryNode(QName name, Object o) throws IOException, IllegalArgumentException { + public void leafSetEntryNode(final QName name, final Object value) { checkNotSealed(); NormalizedNodeBuilderWrapper parent = stack.peek(); - if(parent != null) { - if(hasValidSchema(name, parent)) { - parent.builder().addChild(Builders.leafSetEntryBuilder().withValue(o).withNodeIdentifier( - new YangInstanceIdentifier.NodeWithValue<>(parent.nodeType(), o)).build()); + if (parent != null) { + if (hasValidSchema(name, parent)) { + parent.builder().addChild(Builders.leafSetEntryBuilder().withValue(value) + .withNodeIdentifier(new NodeWithValue<>(parent.nodeType(), value)) + .build()); } } else { - // If there's no parent LeafSetNode then this is a stand alone LeafSetEntryNode. - if(nodePathSchemaNode != null) { - this.normalizedNode = Builders.leafSetEntryBuilder().withValue(o).withNodeIdentifier( - new YangInstanceIdentifier.NodeWithValue<>(name, o)).build(); + // If there's no parent LeafSetNode then this is a stand alone + // LeafSetEntryNode. + if (nodePathSchemaNode != null) { + this.normalizedNode = Builders.leafSetEntryBuilder().withValue(value).withNodeIdentifier( + new NodeWithValue<>(name, value)).build(); } sealed = true; @@ -110,89 +111,74 @@ public class NormalizedNodePruner implements NormalizedNodeStreamWriter { } @Override - public void startContainerNode(YangInstanceIdentifier.NodeIdentifier nodeIdentifier, int i) throws IOException, IllegalArgumentException { - + public void startContainerNode(final NodeIdentifier nodeIdentifier, final int count) { checkNotSealed(); - addBuilder(Builders.containerBuilder().withNodeIdentifier(nodeIdentifier), nodeIdentifier); } @Override - public void startYangModeledAnyXmlNode(YangInstanceIdentifier.NodeIdentifier nodeIdentifier, int i) throws IOException, IllegalArgumentException { + public void startYangModeledAnyXmlNode(final NodeIdentifier nodeIdentifier, final int count) { throw new UnsupportedOperationException("Not implemented yet"); } @Override - public void startUnkeyedList(YangInstanceIdentifier.NodeIdentifier nodeIdentifier, int i) throws IOException, IllegalArgumentException { - + public void startUnkeyedList(final NodeIdentifier nodeIdentifier, final int count) { checkNotSealed(); - addBuilder(Builders.unkeyedListBuilder().withNodeIdentifier(nodeIdentifier), nodeIdentifier); } @Override - public void startUnkeyedListItem(YangInstanceIdentifier.NodeIdentifier nodeIdentifier, int i) throws IOException, IllegalStateException { - + public void startUnkeyedListItem(final NodeIdentifier nodeIdentifier, final int count) { checkNotSealed(); - addBuilder(Builders.unkeyedListEntryBuilder().withNodeIdentifier(nodeIdentifier), nodeIdentifier); } @Override - public void startMapNode(YangInstanceIdentifier.NodeIdentifier nodeIdentifier, int i) throws IOException, IllegalArgumentException { - + public void startMapNode(final NodeIdentifier nodeIdentifier, final int count) { checkNotSealed(); - addBuilder(Builders.mapBuilder().withNodeIdentifier(nodeIdentifier), nodeIdentifier); } @Override - public void startMapEntryNode(YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifierWithPredicates, int i) throws IOException, IllegalArgumentException { - + public void startMapEntryNode(final NodeIdentifierWithPredicates nodeIdentifierWithPredicates, final int count) { checkNotSealed(); - - addBuilder(Builders.mapEntryBuilder().withNodeIdentifier(nodeIdentifierWithPredicates), nodeIdentifierWithPredicates); + addBuilder(Builders.mapEntryBuilder().withNodeIdentifier(nodeIdentifierWithPredicates), + nodeIdentifierWithPredicates); } @Override - public void startOrderedMapNode(YangInstanceIdentifier.NodeIdentifier nodeIdentifier, int i) throws IOException, IllegalArgumentException { - + public void startOrderedMapNode(final NodeIdentifier nodeIdentifier, final int count) { checkNotSealed(); - addBuilder(Builders.orderedMapBuilder().withNodeIdentifier(nodeIdentifier), nodeIdentifier); } @Override - public void startChoiceNode(YangInstanceIdentifier.NodeIdentifier nodeIdentifier, int i) throws IOException, IllegalArgumentException { - + public void startChoiceNode(final NodeIdentifier nodeIdentifier, final int count) { checkNotSealed(); - addBuilder(Builders.choiceBuilder().withNodeIdentifier(nodeIdentifier), nodeIdentifier); } @Override - public void startAugmentationNode(YangInstanceIdentifier.AugmentationIdentifier augmentationIdentifier) throws IOException, IllegalArgumentException { - + public void startAugmentationNode(final AugmentationIdentifier augmentationIdentifier) { checkNotSealed(); - addBuilder(Builders.augmentationBuilder().withNodeIdentifier(augmentationIdentifier), augmentationIdentifier); } @SuppressWarnings("unchecked") @Override - public void anyxmlNode(YangInstanceIdentifier.NodeIdentifier nodeIdentifier, Object o) throws IOException, IllegalArgumentException { + public void anyxmlNode(final NodeIdentifier nodeIdentifier, final Object value) { checkNotSealed(); NormalizedNodeBuilderWrapper parent = stack.peek(); - AnyXmlNode anyXmlNode = Builders.anyXmlBuilder().withNodeIdentifier(nodeIdentifier). - withValue((DOMSource) o).build(); - if(parent != null) { - if(hasValidSchema(nodeIdentifier.getNodeType(), parent)) { + AnyXmlNode anyXmlNode = Builders.anyXmlBuilder().withNodeIdentifier(nodeIdentifier).withValue((DOMSource) value) + .build(); + if (parent != null) { + if (hasValidSchema(nodeIdentifier.getNodeType(), parent)) { parent.builder().addChild(anyXmlNode); } } else { // If there's no parent node then this is a stand alone AnyXmlNode. - if(nodePathSchemaNode != null) { + if (nodePathSchemaNode != null) { this.normalizedNode = anyXmlNode; } @@ -200,65 +186,64 @@ public class NormalizedNodePruner implements NormalizedNodeStreamWriter { } } + @SuppressWarnings("unchecked") @Override - public void endNode() throws IOException, IllegalStateException { - + public void endNode() { checkNotSealed(); NormalizedNodeBuilderWrapper child = stack.pop(); - Preconditions.checkState(child != null, "endNode called on an empty stack"); + checkState(child != null, "endNode called on an empty stack"); - if(!child.getSchema().isPresent()) { + if (!child.getSchema().isPresent()) { LOG.debug("Schema not found for {}", child.identifier()); return; } - NormalizedNode normalizedNode = child.builder().build(); - - if(stack.size() > 0) { + NormalizedNode newNode = child.builder().build(); + if (stack.size() > 0) { NormalizedNodeBuilderWrapper parent = stack.peek(); - parent.builder().addChild(normalizedNode); + parent.builder().addChild(newNode); } else { - this.normalizedNode = normalizedNode; + this.normalizedNode = newNode; sealed = true; } } @Override - public void close() throws IOException { + public void close() { sealed = true; } @Override - public void flush() throws IOException { - + public void flush() { + // No-op } - public NormalizedNode normalizedNode(){ + public NormalizedNode normalizedNode() { return normalizedNode; } - private void checkNotSealed(){ - Preconditions.checkState(!sealed, "Pruner can be used only once"); + private void checkNotSealed() { + checkState(!sealed, "Pruner can be used only once"); } - private boolean hasValidSchema(QName name, NormalizedNodeBuilderWrapper parent) { + private static boolean hasValidSchema(final QName name, final NormalizedNodeBuilderWrapper parent) { boolean valid = parent.getSchema().isPresent() && parent.getSchema().get().getChild(name) != null; - if(!valid) { + if (!valid) { LOG.debug("Schema not found for {}", name); } return valid; } - private NormalizedNodeBuilderWrapper addBuilder(NormalizedNodeContainerBuilder builder, - PathArgument identifier){ + private NormalizedNodeBuilderWrapper addBuilder(final NormalizedNodeContainerBuilder builder, + final PathArgument identifier) { final Optional> schemaNode; NormalizedNodeBuilderWrapper parent = stack.peek(); - if(parent == null) { + if (parent == null) { schemaNode = Optional.fromNullable(nodePathSchemaNode); - } else if(parent.getSchema().isPresent()) { + } else if (parent.getSchema().isPresent()) { schemaNode = Optional.fromNullable(parent.getSchema().get().getChild(identifier)); } else { schemaNode = Optional.absent(); @@ -269,12 +254,12 @@ public class NormalizedNodePruner implements NormalizedNodeStreamWriter { return wrapper; } - private static DataSchemaContextNode findSchemaNodeForNodePath(YangInstanceIdentifier nodePath, - SchemaContext schemaContext) { + private static DataSchemaContextNode findSchemaNodeForNodePath(final YangInstanceIdentifier nodePath, + final SchemaContext schemaContext) { DataSchemaContextNode schemaNode = DataSchemaContextTree.from(schemaContext).getRoot(); - for(PathArgument arg : nodePath.getPathArguments()) { + for (PathArgument arg : nodePath.getPathArguments()) { schemaNode = schemaNode.getChild(arg); - if(schemaNode == null) { + if (schemaNode == null) { break; } } @@ -286,26 +271,26 @@ public class NormalizedNodePruner implements NormalizedNodeStreamWriter { static class SimpleStack { List stack = new LinkedList<>(); - void push(E element){ + void push(final E element) { stack.add(element); } - E pop(){ - if(size() == 0){ + E pop() { + if (size() == 0) { return null; } return stack.remove(stack.size() - 1); } - E peek(){ - if(size() == 0){ + E peek() { + if (size() == 0) { return null; } return stack.get(stack.size() - 1); } - int size(){ + int size() { return stack.size(); } }