import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.restconf.api.MediaTypes;
import org.opendaylight.restconf.api.query.PrettyPrintParam;
-import org.opendaylight.restconf.nb.rfc8040.jersey.providers.api.RestconfNormalizedNodeWriter;
import org.opendaylight.restconf.nb.rfc8040.legacy.WriterParameters;
import org.opendaylight.restconf.server.spi.FormattableBodySupport;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
final @Nullable XMLNamespace initialNamespace) {
// TODO: Performance: Cache JSON Codec factory and schema context
final var codecs = JSONCodecFactorySupplier.RFC7951.getShared(inference.modelContext());
- return ParameterAwareNormalizedNodeWriter.forStreamWriter(
+ return RestconfNormalizedNodeWriter.forStreamWriter(
JSONNormalizedNodeStreamWriter.createNestedWriter(codecs, inference,
initialNamespace, jsonWriter), writerParameters.depth(), writerParameters.fields());
}
import com.google.common.annotations.Beta;
import com.google.common.collect.Iterables;
+import java.io.Closeable;
+import java.io.Flushable;
import java.io.IOException;
import java.util.List;
import java.util.Map.Entry;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.restconf.api.query.DepthParam;
-import org.opendaylight.restconf.nb.rfc8040.jersey.providers.api.RestconfNormalizedNodeWriter;
import org.opendaylight.yangtools.yang.common.Ordering;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AnyxmlNode;
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.LeafSetNode;
* the backing data, this encapsulates a {@link NormalizedNodeStreamWriter} and allows
* us to write multiple nodes.
*/
+// FIXME: this is a copy&paste from yangtools' NormalizedNodeWriter then adapted for filtering
@Beta
-public class ParameterAwareNormalizedNodeWriter implements RestconfNormalizedNodeWriter {
+public sealed class RestconfNormalizedNodeWriter implements Flushable, Closeable {
private static final QName ROOT_DATA_QNAME = QName.create("urn:ietf:params:xml:ns:netconf:base:1.0", "data");
- private final NormalizedNodeStreamWriter writer;
+ final @NonNull NormalizedNodeStreamWriter writer;
private final Integer maxDepth;
- protected final List<Set<QName>> fields;
- protected int currentDepth = 0;
+ private final List<Set<QName>> fields;
- private ParameterAwareNormalizedNodeWriter(final NormalizedNodeStreamWriter writer, final DepthParam depth,
- final List<Set<QName>> fields) {
+ int currentDepth = 0;
+
+ private RestconfNormalizedNodeWriter(final NormalizedNodeStreamWriter writer, final DepthParam depth,
+ final List<Set<QName>> fields) {
this.writer = requireNonNull(writer);
maxDepth = depth == null ? null : depth.value();
this.fields = fields;
}
- protected final NormalizedNodeStreamWriter getWriter() {
- return writer;
- }
-
/**
* Create a new writer backed by a {@link NormalizedNodeStreamWriter}.
*
* @param maxDepth Maximal depth to write
* @return A new instance.
*/
- public static @NonNull ParameterAwareNormalizedNodeWriter forStreamWriter(final NormalizedNodeStreamWriter writer,
+ public static @NonNull RestconfNormalizedNodeWriter forStreamWriter(final NormalizedNodeStreamWriter writer,
final @Nullable DepthParam maxDepth) {
return forStreamWriter(writer, true, maxDepth, null);
}
* @param fields Selected child nodes to write
* @return A new instance.
*/
- public static @NonNull ParameterAwareNormalizedNodeWriter forStreamWriter(final NormalizedNodeStreamWriter writer,
- final @Nullable DepthParam maxDepth, final List<Set<QName>> fields) {
+ public static @NonNull RestconfNormalizedNodeWriter forStreamWriter(final NormalizedNodeStreamWriter writer,
+ final @Nullable DepthParam maxDepth, final @Nullable List<Set<QName>> fields) {
return forStreamWriter(writer, true, maxDepth, fields);
}
* @param fields Selected child nodes to write
* @return A new instance.
*/
- public static @NonNull ParameterAwareNormalizedNodeWriter forStreamWriter(final NormalizedNodeStreamWriter writer,
+ public static @NonNull RestconfNormalizedNodeWriter forStreamWriter(final NormalizedNodeStreamWriter writer,
final boolean orderKeyLeaves, final DepthParam depth, final List<Set<QName>> fields) {
- return orderKeyLeaves ? new OrderedParameterAwareNormalizedNodeWriter(writer, depth, fields)
- : new ParameterAwareNormalizedNodeWriter(writer, depth, fields);
+ return orderKeyLeaves ? new OrderedRestconfNormalizedNodeWriter(writer, depth, fields)
+ : new RestconfNormalizedNodeWriter(writer, depth, fields);
}
/**
- * Iterate over the provided {@link NormalizedNode} and emit write
- * events to the encapsulated {@link NormalizedNodeStreamWriter}.
+ * Iterate over the provided {@link NormalizedNode} and emit write events to the encapsulated
+ * {@link NormalizedNodeStreamWriter}.
*
* @param node Node
* @return {@code ParameterAwareNormalizedNodeWriter}
* @throws IOException when thrown from the backing writer.
*/
- @Override
- public final ParameterAwareNormalizedNodeWriter write(final NormalizedNode node) throws IOException {
- if (wasProcessedAsCompositeNode(node)) {
+ public final RestconfNormalizedNodeWriter write(final NormalizedNode node) throws IOException {
+ if (wasProcessedAsCompositeNode(node) || wasProcessAsSimpleNode(node)) {
return this;
}
-
- if (wasProcessAsSimpleNode(node)) {
- return this;
- }
-
throw new IllegalStateException("It wasn't possible to serialize node " + node);
}
@Override
- public void flush() throws IOException {
+ public final void flush() throws IOException {
writer.flush();
}
@Override
- public void close() throws IOException {
+ public final void close() throws IOException {
writer.flush();
writer.close();
}
writer.scalarValue(nodeAsLeafList.body());
writer.endNode();
}
- return true;
} else if (node instanceof LeafNode<?> nodeAsLeaf) {
writer.startLeafNode(nodeAsLeaf.name());
writer.scalarValue(nodeAsLeaf.body());
writer.endNode();
- return true;
} else if (node instanceof AnyxmlNode<?> anyxmlNode) {
- final Class<?> objectModel = anyxmlNode.bodyObjectModel();
+ final var objectModel = anyxmlNode.bodyObjectModel();
if (writer.startAnyxmlNode(anyxmlNode.name(), objectModel)) {
if (DOMSource.class.isAssignableFrom(objectModel)) {
writer.domSourceValue((DOMSource) anyxmlNode.body());
}
writer.endNode();
}
- return true;
} else if (node instanceof AnydataNode<?> anydataNode) {
- final Class<?> objectModel = anydataNode.bodyObjectModel();
+ final var objectModel = anydataNode.bodyObjectModel();
if (writer.startAnydataNode(anydataNode.name(), objectModel)) {
writer.scalarValue(anydataNode.body());
writer.endNode();
}
- return true;
+ } else {
+ return false;
}
-
- return false;
+ return true;
}
/**
* @return True
* @throws IOException when the writer reports it
*/
- protected final boolean writeChildren(final Iterable<? extends NormalizedNode> children,
- final boolean mixinParent) throws IOException {
- for (final NormalizedNode child : children) {
+ protected final boolean writeChildren(final Iterable<? extends NormalizedNode> children, final boolean mixinParent)
+ throws IOException {
+ for (var child : children) {
if (selectedByParameters(child, mixinParent)) {
write(child);
}
return true;
}
- protected boolean writeMapEntryChildren(final MapEntryNode mapEntryNode) throws IOException {
+ private boolean writeMapEntryChildren(final MapEntryNode mapEntryNode) throws IOException {
if (selectedByParameters(mapEntryNode, false)) {
writeChildren(mapEntryNode.body(), false);
} else if (fields == null && maxDepth != null && currentDepth == maxDepth) {
writer.endNode();
}
- protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
+ boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
writer.startMapEntryNode(node.name(), node.size());
currentDepth++;
writeMapEntryChildren(node);
return processedAsCompositeNode;
}
- private static final class OrderedParameterAwareNormalizedNodeWriter extends ParameterAwareNormalizedNodeWriter {
- private static final Logger LOG = LoggerFactory.getLogger(OrderedParameterAwareNormalizedNodeWriter.class);
+ private static final class OrderedRestconfNormalizedNodeWriter extends RestconfNormalizedNodeWriter {
+ private static final Logger LOG = LoggerFactory.getLogger(OrderedRestconfNormalizedNodeWriter.class);
- OrderedParameterAwareNormalizedNodeWriter(final NormalizedNodeStreamWriter writer, final DepthParam depth,
- final List<Set<QName>> fields) {
+ OrderedRestconfNormalizedNodeWriter(final NormalizedNodeStreamWriter writer, final DepthParam depth,
+ final List<Set<QName>> fields) {
super(writer, depth, fields);
}
@Override
- protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
- final NormalizedNodeStreamWriter writer = getWriter();
+ boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
writer.startMapEntryNode(node.name(), node.size());
- final Set<QName> qnames = node.name().keySet();
+ final var qnames = node.name().keySet();
// Write out all the key children
currentDepth++;
- for (final QName qname : qnames) {
- final DataContainerChild child = node.childByArg(new NodeIdentifier(qname));
+ for (var qname : qnames) {
+ final var child = node.childByArg(new NodeIdentifier(qname));
if (child != null) {
if (selectedByParameters(child, false)) {
write(child);
LOG.info("No child for key element {} found", qname);
}
}
- currentDepth--;
- currentDepth++;
// Write all the rest
- final boolean result =
- writeChildren(Iterables.filter(node.body(), input -> {
- if (!qnames.contains(input.name().getNodeType())) {
- return true;
- }
+ final boolean result = writeChildren(Iterables.filter(node.body(), input -> {
+ if (!qnames.contains(input.name().getNodeType())) {
+ return true;
+ }
- LOG.debug("Skipping key child {}", input);
- return false;
- }), false);
+ LOG.debug("Skipping key child {}", input);
+ return false;
+ }), false);
currentDepth--;
return result;
}
import javax.xml.stream.XMLStreamWriter;
import org.opendaylight.restconf.api.MediaTypes;
import org.opendaylight.restconf.api.query.PrettyPrintParam;
-import org.opendaylight.restconf.nb.rfc8040.jersey.providers.api.RestconfNormalizedNodeWriter;
import org.opendaylight.restconf.nb.rfc8040.legacy.WriterParameters;
import org.opendaylight.restconf.server.spi.FormattableBodySupport;
import org.opendaylight.yangtools.yang.common.QName;
private static RestconfNormalizedNodeWriter createNormalizedNodeWriter(final XMLStreamWriter xmlWriter,
final Inference inference, final WriterParameters writerParameters) {
- return ParameterAwareNormalizedNodeWriter.forStreamWriter(
+ return RestconfNormalizedNodeWriter.forStreamWriter(
XMLStreamNormalizedNodeStreamWriter.create(xmlWriter, inference),
writerParameters.depth(), writerParameters.fields());
}
+++ /dev/null
-/*
- * Copyright (c) 2015 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.restconf.nb.rfc8040.jersey.providers.api;
-
-import java.io.Closeable;
-import java.io.Flushable;
-import java.io.IOException;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-
-public interface RestconfNormalizedNodeWriter extends Flushable, Closeable {
-
- RestconfNormalizedNodeWriter write(NormalizedNode node) throws IOException;
-}
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfFuture;
import org.opendaylight.restconf.common.errors.SettableRestconfFuture;
-import org.opendaylight.restconf.nb.rfc8040.jersey.providers.ParameterAwareNormalizedNodeWriter;
+import org.opendaylight.restconf.nb.rfc8040.jersey.providers.RestconfNormalizedNodeWriter;
import org.opendaylight.restconf.nb.rfc8040.legacy.WriterParameters;
import org.opendaylight.restconf.server.api.DataGetParams;
import org.opendaylight.restconf.server.api.DataGetResult;
/**
* Translate a {@link FieldsParam} to a complete list of child nodes organized into levels, suitable for use with
- * {@link ParameterAwareNormalizedNodeWriter}.
+ * {@link RestconfNormalizedNodeWriter}.
*
* <p>
* Fields parser that stores set of {@link QName}s in each level. Because of this fact, from the output it is only
import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
/**
- * Unit test for {@link ParameterAwareNormalizedNodeWriter} used with depth parameter.
+ * Unit test for {@link RestconfNormalizedNodeWriter} used with depth parameter.
*/
@RunWith(MockitoJUnitRunner.StrictStubs.class)
-public class ParameterAwareNormalizedNodeWriterDepthTest {
+public class RestconfNormalizedNodeWriterDepthTest {
private final String leafSetEntryNodeValue = "leaf-set-value";
private final String keyLeafNodeValue = "key-value";
private final String anotherLeafNodeValue = "another-value";
*/
@Test
public void writeContainerWithoutChildrenDepthTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
parameterWriter.write(containerNodeData);
*/
@Test
public void writeContainerWithChildrenDepthTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
parameterWriter.write(containerNodeData);
*/
@Test
public void writeMapNodeWithoutChildrenDepthTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
parameterWriter.write(mapNodeData);
@Ignore
@Test
public void writeMapNodeWithChildrenDepthTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
parameterWriter.write(mapNodeData);
*/
@Test
public void writeLeafSetNodeWithoutChildrenDepthTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
parameterWriter.write(leafSetNodeData);
*/
@Test
public void writeLeafSetNodeWithChildrenDepthTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
parameterWriter.write(leafSetNodeData);
*/
@Test
public void writeLeafSetEntryNodeDepthTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
parameterWriter.write(leafSetEntryNodeData);
*/
@Test
public void writeMapEntryNodeUnorderedOnlyKeysDepthTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, false, DepthParam.min(),
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, false, DepthParam.min(),
null);
parameterWriter.write(mapEntryNodeData);
*/
@Test
public void writeMapEntryNodeUnorderedDepthTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, false, DepthParam.max(),
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, false, DepthParam.max(),
null);
parameterWriter.write(mapEntryNodeData);
*/
@Test
public void writeMapEntryNodeOrderedWithoutChildrenTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
parameterWriter.write(mapEntryNodeData);
@Ignore
@Test
public void writeMapEntryNodeOrderedTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
parameterWriter.write(mapEntryNodeData);
import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
/**
- * Unit test for {@link ParameterAwareNormalizedNodeWriter} used with fields parameter.
+ * Unit test for {@link RestconfNormalizedNodeWriter} used with fields parameter.
*/
@RunWith(MockitoJUnitRunner.StrictStubs.class)
-public class ParameterAwareNormalizedNodeWriterFieldsTest {
+public class RestconfNormalizedNodeWriterFieldsTest {
private final String leafSetEntryNodeValue = "leaf-set-value";
private final String keyLeafNodeValue = "key-value";
private final NodeIdentifier containerNodeIdentifier =
*/
@Test
public void writeContainerWithLimitedFieldsTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, null, List.of(Set.of()));
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, null, List.of(Set.of()));
parameterWriter.write(containerNodeData);
*/
@Test
public void writeContainerAllFieldsTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(
writer, null, List.of(Set.of(leafSetNodeIdentifier.getNodeType())));
parameterWriter.write(containerNodeData);
*/
@Test
public void writeMapEntryNodeWithLimitedFieldsTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, null, List.of(Set.of()));
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, null, List.of(Set.of()));
parameterWriter.write(mapNodeData);
*/
@Test
public void writeMapNodeAllFieldsTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, null,
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, null,
List.of(Set.of(keyLeafNodeData.name().getNodeType())));
parameterWriter.write(mapNodeData);
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
/**
- * Unit test for {@link ParameterAwareNormalizedNodeWriter} used with all parameters.
+ * Unit test for {@link RestconfNormalizedNodeWriter} used with all parameters.
*/
@RunWith(MockitoJUnitRunner.StrictStubs.class)
-public class ParameterAwareNormalizedNodeWriterParametersTest {
+public class RestconfNormalizedNodeWriterParametersTest {
private final String leafSetEntryNodeValue = "leaf-set-value";
private final NodeIdentifier containerNodeIdentifier =
NodeIdentifier.create(QName.create("namespace", "container"));
*/
@Test
public void writeContainerParameterPrioritiesTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, DepthParam.min(),
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, DepthParam.min(),
List.of(
Set.of(leafSetNodeIdentifier.getNodeType()),
Set.of(leafSetEntryNodeIdentifier.getNodeType())));
*/
@Test
public void writeRootDataTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, null);
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, null);
parameterWriter.write(rootDataContainerData);
@Test
public void writeEmptyRootContainerTest() throws Exception {
- final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, null);
+ final var parameterWriter = RestconfNormalizedNodeWriter.forStreamWriter(writer, null);
parameterWriter.write(ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(new NodeIdentifier(SchemaContext.NAME))