- * 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.
*
+ *
+ * This class is not final for purposes of customization, normal users should not need to subclass it.
*/
public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStreamWriter {
-
@SuppressWarnings("rawtypes")
- private final Deque builders = new ArrayDeque<>();
+ private final Deque builders = new ArrayDeque<>();
+
+ private DataSchemaNode nextSchema;
@SuppressWarnings("rawtypes")
- private ImmutableNormalizedNodeStreamWriter( final NormalizedNodeContainerBuilder topLevelBuilder) {
+ protected ImmutableNormalizedNodeStreamWriter(final NormalizedNodeBuilder 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 @NonNull 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.
+ * 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.
+ * 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.
+ * 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} which will write item to supplied result holder.
*/
- public static final NormalizedNodeStreamWriter from(final NormalizedNodeResult result) {
- return new ImmutableNormalizedNodeStreamWriter(new NormalizedNodeResultBuilder(result));
+ public static @NonNull NormalizedNodeStreamWriter from(final NormalizedNodeResult result) {
+ return result instanceof NormalizedNodeMetadataResult ? from((NormalizedNodeMetadataResult) result)
+ : new ImmutableNormalizedNodeStreamWriter(result);
}
-
- @SuppressWarnings("rawtypes")
- private NormalizedNodeContainerBuilder getCurrent() {
- return builders.peek();
+ /**
+ * 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 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} which will write item to supplied result holder.
+ */
+ public static @NonNull NormalizedNodeStreamWriter from(final NormalizedNodeMetadataResult result) {
+ return new ImmutableMetadataNormalizedNodeStreamWriter(result);
}
- @SuppressWarnings("rawtypes")
- private void enter(final NormalizedNodeContainerBuilder next) {
- builders.push(next);
+ @Override
+ public void startLeafNode(final NodeIdentifier name) {
+ checkDataNodeContainer();
+ enter(name, leafNodeBuilder(nextSchema));
+ nextSchema = null;
}
- @SuppressWarnings("unchecked")
- private void writeChild(final NormalizedNode child) {
- getCurrent().addChild(child);
+ @Override
+ public void startLeafSet(final NodeIdentifier name, final int childSizeHint) {
+ checkDataNodeContainer();
+ enter(name, UNKNOWN_SIZE == childSizeHint ? InterningLeafSetNodeBuilder.create(nextSchema)
+ : InterningLeafSetNodeBuilder.create(nextSchema, childSizeHint));
}
@Override
- @SuppressWarnings({"rawtypes","unchecked"})
- public void endNode() {
- final NormalizedNodeContainerBuilder finishedBuilder = builders.poll();
- Preconditions.checkState(finishedBuilder != null, "Node which should be closed does not exists.");
- NormalizedNodeContainerBuilder current = getCurrent();
- Preconditions.checkState(current != null, "Reached top level node, which could not be closed in this writer.");
- NormalizedNode product = finishedBuilder.build();
- current.addChild(product);
+ public void startLeafSetEntryNode(final NodeWithValue name) {
+ final NormalizedNodeBuilder current = current();
+ checkArgument(current instanceof ImmutableLeafSetNodeBuilder
+ || current instanceof ImmutableOrderedLeafSetNodeBuilder || current instanceof NormalizedNodeResultBuilder,
+ "LeafSetEntryNode is not valid for parent %s", current);
+ enter(name, leafsetEntryNodeBuilder());
+ nextSchema = null;
}
@Override
- public void leafNode(final NodeIdentifier name, final Object value) throws IllegalArgumentException {
+ public void startOrderedLeafSet(final NodeIdentifier name, final int childSizeHint) {
checkDataNodeContainer();
- writeChild(ImmutableNodes.leafNode(name, value));
+ enter(name, Builders.orderedLeafSetBuilder());
}
@Override
- public void startLeafSet(final NodeIdentifier name, final int childSizeHint) throws IllegalArgumentException {
+ public boolean startAnyxmlNode(final NodeIdentifier name, final Class objectModel) {
checkDataNodeContainer();
- ListNodeBuilder> builder = UNKNOWN_SIZE == childSizeHint ?
- ImmutableLeafSetNodeBuilder.create() : ImmutableLeafSetNodeBuilder.create(childSizeHint);
- builder.withNodeIdentifier(name);
- enter(builder);
+ if (DOMSource.class.isAssignableFrom(objectModel)) {
+ enter(name, ImmutableAnyXmlNodeBuilder.create());
+ nextSchema = null;
+ return true;
+ }
+ return false;
}
@Override
- public void leafSetEntryNode(final Object value) throws IllegalArgumentException {
- Preconditions.checkArgument(getCurrent() instanceof ImmutableLeafSetNodeBuilder);
- @SuppressWarnings("unchecked")
- ListNodeBuilder> builder = ((ImmutableLeafSetNodeBuilder