import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.codec.SchemaTracker;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
*/
public abstract class JSONNormalizedNodeStreamWriter implements NormalizedNodeStreamWriter {
private static final class Exclusive extends JSONNormalizedNodeStreamWriter {
- Exclusive(final JSONCodecFactory codecFactory, final SchemaPath path, final JsonWriter writer,
+ Exclusive(final JSONCodecFactory codecFactory, final SchemaTracker tracker, final JsonWriter writer,
final JSONStreamWriterRootContext rootContext) {
- super(codecFactory, path, writer, rootContext);
+ super(codecFactory, tracker, writer, rootContext);
}
@Override
}
private static final class Nested extends JSONNormalizedNodeStreamWriter {
- Nested(final JSONCodecFactory codecFactory, final SchemaPath path, final JsonWriter writer,
+ Nested(final JSONCodecFactory codecFactory, final SchemaTracker tracker, final JsonWriter writer,
final JSONStreamWriterRootContext rootContext) {
- super(codecFactory, path, writer, rootContext);
+ super(codecFactory, tracker, writer, rootContext);
}
@Override
private final JsonWriter writer;
private JSONStreamWriterContext context;
- JSONNormalizedNodeStreamWriter(final JSONCodecFactory codecFactory, final SchemaPath path, final JsonWriter writer,
- final JSONStreamWriterRootContext rootContext) {
+ JSONNormalizedNodeStreamWriter(final JSONCodecFactory codecFactory, final SchemaTracker tracker,
+ final JsonWriter writer, final JSONStreamWriterRootContext rootContext) {
this.writer = requireNonNull(writer);
this.codecs = requireNonNull(codecFactory);
- this.tracker = SchemaTracker.create(codecFactory.getSchemaContext(), path);
+ this.tracker = requireNonNull(tracker);
this.context = requireNonNull(rootContext);
}
*/
public static NormalizedNodeStreamWriter createExclusiveWriter(final JSONCodecFactory codecFactory,
final SchemaPath path, final URI initialNs, final JsonWriter jsonWriter) {
- return new Exclusive(codecFactory, path, jsonWriter, new JSONStreamWriterExclusiveRootContext(initialNs));
+ return new Exclusive(codecFactory, SchemaTracker.create(codecFactory.getSchemaContext(), path), jsonWriter,
+ new JSONStreamWriterExclusiveRootContext(initialNs));
+ }
+
+ /**
+ * Create a new stream writer, which writes to the specified output stream.
+ *
+ * <p>
+ * The codec factory can be reused between multiple writers.
+ *
+ * <p>
+ * Returned writer is exclusive user of JsonWriter, which means it will start
+ * top-level JSON element and ends it.
+ *
+ * <p>
+ * This instance of writer can be used only to emit one top level element,
+ * otherwise it will produce incorrect JSON. Closing this instance will close
+ * the writer too.
+ *
+ * @param codecFactory JSON codec factory
+ * @param rootNode Root node
+ * @param initialNs Initial namespace
+ * @param jsonWriter JsonWriter
+ * @return A stream writer instance
+ */
+ public static NormalizedNodeStreamWriter createExclusiveWriter(final JSONCodecFactory codecFactory,
+ final DataNodeContainer rootNode, final URI initialNs, final JsonWriter jsonWriter) {
+ return new Exclusive(codecFactory, SchemaTracker.create(rootNode), jsonWriter,
+ new JSONStreamWriterExclusiveRootContext(initialNs));
}
/**
*/
public static NormalizedNodeStreamWriter createNestedWriter(final JSONCodecFactory codecFactory,
final SchemaPath path, final URI initialNs, final JsonWriter jsonWriter) {
- return new Nested(codecFactory, path, jsonWriter, new JSONStreamWriterSharedRootContext(initialNs));
+ return new Nested(codecFactory, SchemaTracker.create(codecFactory.getSchemaContext(), path), jsonWriter,
+ new JSONStreamWriterSharedRootContext(initialNs));
+ }
+
+ /**
+ * Create a new stream writer, which writes to the specified output stream.
+ *
+ * <p>
+ * The codec factory can be reused between multiple writers.
+ *
+ * <p>
+ * Returned writer can be used emit multiple top level element,
+ * but does not start / close parent JSON object, which must be done
+ * by user providing {@code jsonWriter} instance in order for
+ * JSON to be valid. Closing this instance <strong>will not</strong>
+ * close the wrapped writer; the caller must take care of that.
+ *
+ * @param codecFactory JSON codec factory
+ * @param rootNode Root node
+ * @param initialNs Initial namespace
+ * @param jsonWriter JsonWriter
+ * @return A stream writer instance
+ */
+ public static NormalizedNodeStreamWriter createNestedWriter(final JSONCodecFactory codecFactory,
+ final DataNodeContainer rootNode, final URI initialNs, final JsonWriter jsonWriter) {
+ return new Nested(codecFactory, SchemaTracker.create(rootNode), jsonWriter,
+ new JSONStreamWriterSharedRootContext(initialNs));
}
@Override
*/
package org.opendaylight.yangtools.yang.data.codec.xml;
+import static java.util.Objects.requireNonNull;
+
import java.io.IOException;
import java.util.Collections;
import java.util.Map;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
final class SchemaAwareXMLStreamNormalizedNodeStreamWriter extends XMLStreamNormalizedNodeStreamWriter<SchemaNode>
implements SchemaContextProvider {
private final SchemaAwareXMLStreamWriterUtils streamUtils;
SchemaAwareXMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer, final SchemaContext context,
- final SchemaPath path) {
+ final SchemaTracker tracker) {
super(writer);
- this.tracker = SchemaTracker.create(context, path);
+ this.tracker = requireNonNull(tracker);
this.streamUtils = new SchemaAwareXMLStreamWriterUtils(context);
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamAttributeWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
+import org.opendaylight.yangtools.yang.data.impl.codec.SchemaTracker;
+import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.w3c.dom.Element;
* @param context Associated {@link SchemaContext}.
* @return A new {@link NormalizedNodeStreamWriter}
*/
- public static NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context) {
- return create(writer, context, SchemaPath.ROOT);
+ public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
+ final SchemaContext context) {
+ return create(writer, context, context);
+ }
+
+ /**
+ * Create a new writer with the specified context and rooted at the specified node.
+ *
+ * @param writer Output {@link XMLStreamWriter}
+ * @param context Associated {@link SchemaContext}.
+ * @param rootNode Root node
+ * @return A new {@link NormalizedNodeStreamWriter}
+ */
+ public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context,
+ final DataNodeContainer rootNode) {
+ return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context, SchemaTracker.create(rootNode));
}
/**
* @param writer Output {@link XMLStreamWriter}
* @param context Associated {@link SchemaContext}.
* @param path path
- *
* @return A new {@link NormalizedNodeStreamWriter}
*/
public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context,
final SchemaPath path) {
- return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context, path);
+ return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context, SchemaTracker.create(context, path));
}
/**
package org.opendaylight.yangtools.yang.data.impl.codec;
import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
import com.google.common.collect.Iterables;
import java.util.Collection;
import java.util.Deque;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.odlext.model.api.YangModeledAnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
private final Deque<Object> schemaStack = new ArrayDeque<>();
private final DataNodeContainer root;
- private SchemaTracker(final SchemaContext context, final SchemaPath path) {
- final Collection<SchemaNode> schemaNodes = SchemaUtils.findParentSchemaNodesOnPath(context, path);
- checkArgument(!schemaNodes.isEmpty(), "Unable to find schema node for supplied schema path: %s", path);
- if (schemaNodes.size() > 1) {
- LOG.warn("More possible schema nodes {} for supplied schema path {}", schemaNodes, path);
- }
- final Optional<SchemaNode> current = schemaNodes.stream().filter(node -> node instanceof DataNodeContainer)
- .findFirst();
- checkArgument(current.isPresent(),
- "Schema path must point to container or list or an rpc input/output. Supplied path %s pointed to: %s",
- path, current);
- root = (DataNodeContainer) current.get();
+ private SchemaTracker(final DataNodeContainer root) {
+ this.root = requireNonNull(root);
}
/**
* @param context Associated {@link SchemaContext}.
* @return A new {@link NormalizedNodeStreamWriter}
*/
- public static SchemaTracker create(final SchemaContext context) {
- return create(context, SchemaPath.ROOT);
+ // FIXME: 3.0.0: remove this method
+ public static @NonNull SchemaTracker create(final SchemaContext context) {
+ return new SchemaTracker(context);
+ }
+
+ /**
+ * Create a new writer with the specified node as its root.
+ *
+ * @param root Root node
+ * @return A new {@link NormalizedNodeStreamWriter}
+ */
+ public static @NonNull SchemaTracker create(final DataNodeContainer root) {
+ return new SchemaTracker(root);
}
/**
* @param path schema path
* @return A new {@link NormalizedNodeStreamWriter}
*/
- public static SchemaTracker create(final SchemaContext context, final SchemaPath path) {
- return new SchemaTracker(context, path);
+ public static @NonNull SchemaTracker create(final SchemaContext context, final SchemaPath path) {
+ final Collection<SchemaNode> schemaNodes = SchemaUtils.findParentSchemaNodesOnPath(context, path);
+ checkArgument(!schemaNodes.isEmpty(), "Unable to find schema node for supplied schema path: %s", path);
+ if (schemaNodes.size() > 1) {
+ LOG.warn("More possible schema nodes {} for supplied schema path {}", schemaNodes, path);
+ }
+ final Optional<DataNodeContainer> current = schemaNodes.stream()
+ .filter(node -> node instanceof DataNodeContainer).map(DataNodeContainer.class::cast)
+ .findFirst();
+ checkArgument(current.isPresent(),
+ "Schema path must point to container or list or an rpc input/output. Supplied path %s pointed to: %s",
+ path, current);
+ return new SchemaTracker(current.get());
}
public Object getParent() {