- * This writer supports two modes of behaviour one is using {@link #from(NormalizedNodeResult)}
- * where resulting NormalizedNode will be stored in supplied result object.
- *
- * Other mode of operation is using {@link #from(NormalizedNodeContainerBuilder)},
- * where all created nodes will be written to this builder.
- *
+ * This writer supports two modes of behaviour one is using {@link #from(NormalizedNodeResult)} where resulting
+ * NormalizedNode will be stored in supplied result object.
*
+ *
+ * Other mode of operation is using {@link #from(NormalizedNodeContainerBuilder)}, where all created nodes will be
+ * written to this builder.
*/
public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStreamWriter {
-
-
@SuppressWarnings("rawtypes")
- private final Deque builders;
-
+ private final Deque builders = new ArrayDeque<>();
+ private DataSchemaNode nextSchema;
@SuppressWarnings("rawtypes")
- private ImmutableNormalizedNodeStreamWriter( final NormalizedNodeContainerBuilder topLevelBuilder) {
- builders = new ArrayDeque<>();
+ protected ImmutableNormalizedNodeStreamWriter(final NormalizedNodeContainerBuilder topLevelBuilder) {
builders.push(topLevelBuilder);
}
+ protected ImmutableNormalizedNodeStreamWriter(final NormalizedNodeResult result) {
+ this(new NormalizedNodeResultBuilder(result));
+ }
+
/**
- * Creates a {@link NormalizedNodeStreamWriter} which creates instances of supplied
- * {@link NormalizedNode}s and writes them to supplied builder as child nodes.
+ * Creates a {@link NormalizedNodeStreamWriter} which creates instances of supplied {@link NormalizedNode}s
+ * and writes them to supplied builder as child nodes.
+ *
*
- * Type of supplied {@link NormalizedNodeContainerBuilder} affects,
- * which events could be emitted in order to ensure proper construction of
- * data.
+ * Type of supplied {@link NormalizedNodeContainerBuilder} affects, which events could be emitted in order
+ * to ensure proper construction of data.
*
* @param builder Builder to which data will be written.
* @return {@link NormalizedNodeStreamWriter} which writes data
*/
- public static final NormalizedNodeStreamWriter from(final NormalizedNodeContainerBuilder builder) {
+ public static NormalizedNodeStreamWriter from(final NormalizedNodeContainerBuilder builder) {
return new ImmutableNormalizedNodeStreamWriter(builder);
}
/**
+ * Creates a {@link NormalizedNodeStreamWriter} which creates one instance of top-level {@link NormalizedNode}
+ * (type of NormalizedNode) is determined by first start event.
*
- * Creates a {@link NormalizedNodeStreamWriter} which creates one instance of top
- * level {@link NormalizedNode} (type of NormalizedNode) is determined by first
- * start event.
- *
- * Result is built when {@link #endNode()} associated with that start event
- * is emitted.
*
- * Writer properly creates also nested {@link NormalizedNode} instances,
- * if their are supported inside the scope of first event.
+ * Result is built when {@link #endNode()} associated with that start event is emitted.
+ *
*
- * This method is useful for clients, which knows there will be one
- * top level node written, but does not know which type of {@link NormalizedNode}
- * will be writen.
+ * Writer properly creates also nested {@link NormalizedNode} instances, if their are supported inside the scope
+ * of the first event.
*
+ *
+ * This method is useful for clients, which knows there will be one top-level node written, but does not know which
+ * type of {@link NormalizedNode} will be written.
*
* @param result {@link NormalizedNodeResult} object which will hold result value.
- * @return {@link NormalizedNodeStreamWriter} whcih will write item to supplied result holder.
+ * @return {@link NormalizedNodeStreamWriter} which will write item to supplied result holder.
*/
- public static final NormalizedNodeStreamWriter from(final NormalizedNodeResult result) {
- return new ImmutableNormalizedNodeStreamWriter(new NormalizedNodeResultBuilder(result));
+ public static NormalizedNodeStreamWriter from(final NormalizedNodeResult result) {
+ return new ImmutableNormalizedNodeStreamWriter(result);
}
+ protected Deque getBuilders() {
+ return builders;
+ }
@SuppressWarnings("rawtypes")
- private NormalizedNodeContainerBuilder getCurrent() {
+ protected NormalizedNodeContainerBuilder getCurrent() {
return builders.peek();
}
@SuppressWarnings("rawtypes")
private void enter(final NormalizedNodeContainerBuilder next) {
builders.push(next);
+ nextSchema = null;
}
@SuppressWarnings("unchecked")
- private void writeChild(final NormalizedNode child) {
+ protected void writeChild(final NormalizedNode child) {
getCurrent().addChild(child);
}
@@ -114,84 +143,163 @@ public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStream
public void endNode() {
final NormalizedNodeContainerBuilder finishedBuilder = builders.poll();
Preconditions.checkState(finishedBuilder != null, "Node which should be closed does not exists.");
- NormalizedNodeContainerBuilder current = getCurrent();
+ final NormalizedNodeContainerBuilder current = getCurrent();
Preconditions.checkState(current != null, "Reached top level node, which could not be closed in this writer.");
- NormalizedNode product = finishedBuilder.build();
+ final NormalizedNode product = finishedBuilder.build();
current.addChild(product);
+ nextSchema = null;
}
@Override
- public void leafNode(final NodeIdentifier name, final Object value) throws IllegalArgumentException {
+ public void leafNode(final NodeIdentifier name, final Object value) {
checkDataNodeContainer();
- writeChild(ImmutableNodes.leafNode(name, value));
+
+ final LeafNode