X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-clustering-commons%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2Fnode%2Futils%2Ftransformer%2FAbstractNormalizedNodePruner.java;h=cee5a0329a75b73eb36947b547bd6c65e6dbfe9f;hb=f40e99a51cd3fc2c9be3ac8aa0772bdb6b6ce479;hp=c3628ad1e8208eab7c85485b78824e94f8688f4f;hpb=26a1c60c198f03780f6a6d916ac24798a08e0910;p=controller.git diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/AbstractNormalizedNodePruner.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/AbstractNormalizedNodePruner.java index c3628ad1e8..cee5a0329a 100644 --- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/AbstractNormalizedNodePruner.java +++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/AbstractNormalizedNodePruner.java @@ -8,6 +8,7 @@ package org.opendaylight.controller.cluster.datastore.node.utils.transformer; import static com.google.common.base.Preconditions.checkState; +import static com.google.common.base.Verify.verify; import static java.util.Objects.requireNonNull; import java.io.IOException; @@ -17,7 +18,6 @@ import java.util.NoSuchElementException; import java.util.Optional; import javax.xml.transform.dom.DOMSource; 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; @@ -25,10 +25,10 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgum 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.impl.schema.ReusableImmutableNormalizedNodeStreamWriter; -import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode; +import org.opendaylight.yangtools.yang.data.util.DataSchemaContext; import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; -import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -44,36 +44,34 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite } @FunctionalInterface - private interface WriterMethod { + interface WriterMethod { void apply(ReusableImmutableNormalizedNodeStreamWriter writer, T name) throws IOException; } @FunctionalInterface - private interface SizedWriterMethod { + interface SizedWriterMethod { void apply(ReusableImmutableNormalizedNodeStreamWriter writer, T name, int childSizeHint) throws IOException; } private static final Logger LOG = LoggerFactory.getLogger(AbstractNormalizedNodePruner.class); - private final Deque> stack = new ArrayDeque<>(); + private final Deque stack = new ArrayDeque<>(); private final ReusableImmutableNormalizedNodeStreamWriter delegate = ReusableImmutableNormalizedNodeStreamWriter.create(); private final DataSchemaContextTree tree; - private DataSchemaContextNode nodePathSchemaNode; + private DataSchemaContext nodePathSchemaNode; + private NormalizedNode normalizedNode; private State state = State.UNITIALIZED; private int unknown; - // FIXME: package-private to support unguarded NormalizedNodePruner access - NormalizedNode normalizedNode; - AbstractNormalizedNodePruner(final DataSchemaContextTree tree) { this.tree = requireNonNull(tree); } - AbstractNormalizedNodePruner(final SchemaContext schemaContext) { + AbstractNormalizedNodePruner(final EffectiveModelContext schemaContext) { this(DataSchemaContextTree.from(schemaContext)); } @@ -91,17 +89,17 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite } @Override - public void startLeafNode(final NodeIdentifier name) throws IOException { + public final void startLeafNode(final NodeIdentifier name) throws IOException { enter(ReusableImmutableNormalizedNodeStreamWriter::startLeafNode, name); } @Override - public void startLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException { + public final void startLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException { enter(ReusableImmutableNormalizedNodeStreamWriter::startLeafSet, name, childSizeHint); } @Override - public void startOrderedLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException { + public final void startOrderedLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException { enter(ReusableImmutableNormalizedNodeStreamWriter::startOrderedLeafSet, name, childSizeHint); } @@ -111,28 +109,22 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite } @Override - public void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException { + public final void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException { enter(ReusableImmutableNormalizedNodeStreamWriter::startContainerNode, name, childSizeHint); } @Override - public void startYangModeledAnyXmlNode(final NodeIdentifier nodeIdentifier, final int count) { - // FIXME: implement this - throw new UnsupportedOperationException("Not implemented yet"); - } - - @Override - public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) throws IOException { + public final void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) throws IOException { enter(ReusableImmutableNormalizedNodeStreamWriter::startUnkeyedList, name, childSizeHint); } @Override - public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException { + public final void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException { enter(ReusableImmutableNormalizedNodeStreamWriter::startUnkeyedListItem, name, childSizeHint); } @Override - public void startMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException { + public final void startMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException { enter(ReusableImmutableNormalizedNodeStreamWriter::startMapNode, name, childSizeHint); } @@ -143,27 +135,32 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite } @Override - public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException { + public final void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException { enter(ReusableImmutableNormalizedNodeStreamWriter::startOrderedMapNode, name, childSizeHint); } @Override - public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) throws IOException { + public final void startChoiceNode(final NodeIdentifier name, final int childSizeHint) throws IOException { enter(ReusableImmutableNormalizedNodeStreamWriter::startChoiceNode, name, childSizeHint); } @Override - public void startAugmentationNode(final AugmentationIdentifier identifier) throws IOException { - enter(ReusableImmutableNormalizedNodeStreamWriter::startAugmentationNode, identifier); + public final boolean startAnyxmlNode(final NodeIdentifier name, final Class objectModel) throws IOException { + if (enter(name)) { + verify(delegate.startAnyxmlNode(name, objectModel), + "Unexpected failure to stream DOMSource node %s model %s", name, objectModel); + } + return true; } @Override - public void startAnyxmlNode(final NodeIdentifier name) throws IOException { - enter(ReusableImmutableNormalizedNodeStreamWriter::startAnyxmlNode, name); + public final boolean startAnydataNode(final NodeIdentifier name, final Class objectModel) throws IOException { + // FIXME: we do not support anydata nodes yet + return false; } @Override - public void domSourceValue(final DOMSource value) throws IOException { + public final void domSourceValue(final DOMSource value) throws IOException { checkNotSealed(); if (unknown == 0) { delegate.domSourceValue(value); @@ -171,20 +168,20 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite } @Override - public void scalarValue(final Object value) throws IOException { + public final void scalarValue(final Object value) throws IOException { checkNotSealed(); if (unknown == 0) { - delegate.scalarValue(translateScalar(stack.peek(), value)); + delegate.scalarValue(translateScalar(currentSchema(), value)); } } - Object translateScalar(final DataSchemaContextNode context, final Object value) throws IOException { + Object translateScalar(final DataSchemaContext context, final Object value) { // Default is pass-through return value; } @Override - public void endNode() throws IOException { + public final void endNode() throws IOException { checkNotSealed(); if (unknown == 0) { @@ -203,20 +200,21 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite } if (stack.isEmpty()) { - normalizedNode = delegate.getResult(); + final var result = delegate.result(); + normalizedNode = result != null ? result.data() : null; state = State.CLOSED; } } @Override - public void close() throws IOException { + public final void close() throws IOException { state = State.CLOSED; stack.clear(); delegate.close(); } @Override - public void flush() throws IOException { + public final void flush() throws IOException { delegate.flush(); } @@ -226,7 +224,7 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite * @return Resulting node for the path, if it was not pruned * @throws IllegalStateException if this pruner has not been closed */ - public final Optional> getResult() { + public final Optional getResult() { checkState(state == State.CLOSED, "Cannot get result in state %s", state); return Optional.ofNullable(normalizedNode); } @@ -244,10 +242,11 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite return false; } - final DataSchemaContextNode schema; - final DataSchemaContextNode parent = stack.peek(); + final DataSchemaContext schema; + final DataSchemaContext parent = currentSchema(); if (parent != null) { - schema = parent.getChild(name); + schema = parent instanceof DataSchemaContext.Composite compositeParent ? compositeParent.childByArg(name) + : null; } else { schema = nodePathSchemaNode; } @@ -259,23 +258,27 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite } stack.push(schema); - final DataSchemaNode dataSchema = schema.getDataSchemaNode(); + final DataSchemaNode dataSchema = schema.dataSchemaNode(); if (dataSchema != null) { delegate.nextDataSchemaNode(dataSchema); } return true; } - private void enter(final WriterMethod method, final A name) throws IOException { + final void enter(final WriterMethod method, final A name) throws IOException { if (enter(name)) { method.apply(delegate, name); } } - private void enter(final SizedWriterMethod method, final A name, final int size) + final void enter(final SizedWriterMethod method, final A name, final int size) throws IOException { if (enter(name)) { method.apply(delegate, name, size); } } + + final DataSchemaContext currentSchema() { + return stack.peek(); + } }