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.PathArgument;
20 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
21 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
22 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
23 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
26 * Abstract base class for implementing {@link NormalizedNodeDataOutput} contract. This class uses
27 * {@link NormalizedNodeStreamWriter} as an internal interface for performing the actual NormalizedNode writeout,
28 * i.e. it will defer to a {@link NormalizedNodeWriter} instance.
31 * As such, this is an implementation detail not exposed from this package, hence implementations can rely on the
32 * stream being initialized with a header and version.
34 abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOutput, NormalizedNodeStreamWriter {
35 // Visible for subclasses
36 final DataOutput output;
38 private NormalizedNodeWriter normalizedNodeWriter;
39 private boolean headerWritten;
41 AbstractNormalizedNodeDataOutput(final DataOutput output) {
42 this.output = requireNonNull(output);
46 private void ensureHeaderWritten() throws IOException {
48 output.writeByte(TokenTypes.SIGNATURE_MARKER);
49 output.writeShort(streamVersion());
55 public final void write(final int value) throws IOException {
56 ensureHeaderWritten();
61 public final void write(final byte[] bytes) throws IOException {
62 ensureHeaderWritten();
67 public final void write(final byte[] bytes, final int off, final int len) throws IOException {
68 ensureHeaderWritten();
69 output.write(bytes, off, len);
73 public final void writeBoolean(final boolean value) throws IOException {
74 ensureHeaderWritten();
75 output.writeBoolean(value);
79 public final void writeByte(final int value) throws IOException {
80 ensureHeaderWritten();
81 output.writeByte(value);
85 public final void writeShort(final int value) throws IOException {
86 ensureHeaderWritten();
87 output.writeShort(value);
91 public final void writeChar(final int value) throws IOException {
92 ensureHeaderWritten();
93 output.writeChar(value);
97 public final void writeInt(final int value) throws IOException {
98 ensureHeaderWritten();
99 output.writeInt(value);
103 public final void writeLong(final long value) throws IOException {
104 ensureHeaderWritten();
105 output.writeLong(value);
109 public final void writeFloat(final float value) throws IOException {
110 ensureHeaderWritten();
111 output.writeFloat(value);
115 public final void writeDouble(final double value) throws IOException {
116 ensureHeaderWritten();
117 output.writeDouble(value);
121 public final void writeBytes(final String str) throws IOException {
122 ensureHeaderWritten();
123 output.writeBytes(str);
127 public final void writeChars(final String str) throws IOException {
128 ensureHeaderWritten();
129 output.writeChars(str);
133 public final void writeUTF(final String str) throws IOException {
134 ensureHeaderWritten();
135 output.writeUTF(str);
139 public final void writeQName(final QName qname) throws IOException {
140 ensureHeaderWritten();
141 writeQNameInternal(qname);
145 public final void writeNormalizedNode(final NormalizedNode<?, ?> node) throws IOException {
146 ensureHeaderWritten();
147 if (normalizedNodeWriter == null) {
148 normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(this);
150 normalizedNodeWriter.write(node);
154 public final void writePathArgument(final PathArgument pathArgument) throws IOException {
155 ensureHeaderWritten();
156 writePathArgumentInternal(pathArgument);
160 public final void writeYangInstanceIdentifier(final YangInstanceIdentifier identifier) throws IOException {
161 ensureHeaderWritten();
162 writeYangInstanceIdentifierInternal(identifier);
166 public final void writeSchemaPath(final SchemaPath path) throws IOException {
167 ensureHeaderWritten();
169 output.writeBoolean(path.isAbsolute());
170 final List<QName> qnames = path.getPath();
171 output.writeInt(qnames.size());
172 for (QName qname : qnames) {
173 writeQNameInternal(qname);
178 public final void close() throws IOException {
183 public void flush() throws IOException {
184 if (output instanceof OutputStream) {
185 ((OutputStream)output).flush();
189 final void writeYangInstanceIdentifierInternal(final YangInstanceIdentifier identifier) throws IOException {
190 List<PathArgument> pathArguments = identifier.getPathArguments();
191 output.writeInt(pathArguments.size());
193 for (PathArgument pathArgument : pathArguments) {
194 writePathArgumentInternal(pathArgument);
198 abstract short streamVersion();
200 abstract void writeQNameInternal(@NonNull QName qname) throws IOException;
202 abstract void writePathArgumentInternal(PathArgument pathArgument) throws IOException;