2 * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.controller.cluster.datastore.node.utils.stream;
10 import static java.util.Objects.requireNonNull;
12 import java.io.DataOutput;
13 import java.io.IOException;
14 import java.io.OutputStream;
15 import java.util.List;
16 import org.eclipse.jdt.annotation.NonNull;
17 import org.opendaylight.yangtools.yang.common.QName;
18 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
19 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
20 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
21 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
22 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
23 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
24 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
27 * Abstract base class for implementing {@link NormalizedNodeDataOutput} contract. This class uses
28 * {@link NormalizedNodeStreamWriter} as an internal interface for performing the actual NormalizedNode writeout,
29 * i.e. it will defer to a {@link NormalizedNodeWriter} instance.
32 * As such, this is an implementation detail not exposed from this package, hence implementations can rely on the
33 * stream being initialized with a header and version.
35 abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOutput, NormalizedNodeStreamWriter {
36 // Visible for subclasses
37 final DataOutput output;
39 private NormalizedNodeWriter normalizedNodeWriter;
40 private boolean headerWritten;
42 AbstractNormalizedNodeDataOutput(final DataOutput output) {
43 this.output = requireNonNull(output);
47 private void ensureHeaderWritten() throws IOException {
49 output.writeByte(TokenTypes.SIGNATURE_MARKER);
50 output.writeShort(streamVersion());
56 public final void write(final int value) throws IOException {
57 ensureHeaderWritten();
62 public final void write(final byte[] bytes) throws IOException {
63 ensureHeaderWritten();
68 public final void write(final byte[] bytes, final int off, final int len) throws IOException {
69 ensureHeaderWritten();
70 output.write(bytes, off, len);
74 public final void writeBoolean(final boolean value) throws IOException {
75 ensureHeaderWritten();
76 output.writeBoolean(value);
80 public final void writeByte(final int value) throws IOException {
81 ensureHeaderWritten();
82 output.writeByte(value);
86 public final void writeShort(final int value) throws IOException {
87 ensureHeaderWritten();
88 output.writeShort(value);
92 public final void writeChar(final int value) throws IOException {
93 ensureHeaderWritten();
94 output.writeChar(value);
98 public final void writeInt(final int value) throws IOException {
99 ensureHeaderWritten();
100 output.writeInt(value);
104 public final void writeLong(final long value) throws IOException {
105 ensureHeaderWritten();
106 output.writeLong(value);
110 public final void writeFloat(final float value) throws IOException {
111 ensureHeaderWritten();
112 output.writeFloat(value);
116 public final void writeDouble(final double value) throws IOException {
117 ensureHeaderWritten();
118 output.writeDouble(value);
122 public final void writeBytes(final String str) throws IOException {
123 ensureHeaderWritten();
124 output.writeBytes(str);
128 public final void writeChars(final String str) throws IOException {
129 ensureHeaderWritten();
130 output.writeChars(str);
134 public final void writeUTF(final String str) throws IOException {
135 ensureHeaderWritten();
136 output.writeUTF(str);
140 public final void writeQName(final QName qname) throws IOException {
141 ensureHeaderWritten();
142 writeQNameInternal(qname);
146 public final void writeNormalizedNode(final NormalizedNode<?, ?> node) throws IOException {
147 ensureHeaderWritten();
148 if (normalizedNodeWriter == null) {
149 normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(this);
151 normalizedNodeWriter.write(node);
155 public final void writePathArgument(final PathArgument pathArgument) throws IOException {
156 ensureHeaderWritten();
157 writePathArgumentInternal(pathArgument);
161 public final void writeYangInstanceIdentifier(final YangInstanceIdentifier identifier) throws IOException {
162 ensureHeaderWritten();
163 writeYangInstanceIdentifierInternal(identifier);
167 public final void writeSchemaPath(final SchemaPath path) throws IOException {
168 ensureHeaderWritten();
170 output.writeBoolean(path.isAbsolute());
171 final List<QName> qnames = path.getPath();
172 output.writeInt(qnames.size());
173 for (QName qname : qnames) {
174 writeQNameInternal(qname);
179 public final void close() throws IOException {
184 public void flush() throws IOException {
185 if (output instanceof OutputStream) {
186 ((OutputStream)output).flush();
191 public final boolean startAnydataNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
192 // FIXME: We do not support anydata nodes of any kind, yet
196 abstract short streamVersion();
198 abstract void writeQNameInternal(@NonNull QName qname) throws IOException;
200 abstract void writePathArgumentInternal(PathArgument pathArgument) throws IOException;
202 abstract void writeYangInstanceIdentifierInternal(YangInstanceIdentifier identifier) throws IOException;