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.yangtools.yang.data.codec.binfmt;
10 import static java.util.Objects.requireNonNull;
12 import com.google.common.collect.Iterables;
13 import java.io.DataOutput;
14 import java.io.IOException;
15 import java.io.OutputStream;
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;
25 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
26 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
29 * Abstract base class for implementing {@link NormalizedNodeDataOutput} contract. This class uses
30 * {@link NormalizedNodeStreamWriter} as an internal interface for performing the actual NormalizedNode writeout,
31 * i.e. it will defer to a {@link NormalizedNodeWriter} instance.
34 * As such, this is an implementation detail not exposed from this package, hence implementations can rely on the
35 * stream being initialized with a header and version.
37 abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOutput, NormalizedNodeStreamWriter {
38 // Visible for subclasses
39 final DataOutput output;
41 private NormalizedNodeWriter normalizedNodeWriter;
42 private boolean headerWritten;
44 AbstractNormalizedNodeDataOutput(final DataOutput output) {
45 this.output = requireNonNull(output);
49 private void ensureHeaderWritten() throws IOException {
51 output.writeByte(TokenTypes.SIGNATURE_MARKER);
52 output.writeShort(streamVersion());
58 public final void write(final int value) throws IOException {
59 ensureHeaderWritten();
64 public final void write(final byte[] bytes) throws IOException {
65 ensureHeaderWritten();
70 public final void write(final byte[] bytes, final int off, final int len) throws IOException {
71 ensureHeaderWritten();
72 output.write(bytes, off, len);
76 public final void writeBoolean(final boolean value) throws IOException {
77 ensureHeaderWritten();
78 output.writeBoolean(value);
82 public final void writeByte(final int value) throws IOException {
83 ensureHeaderWritten();
84 output.writeByte(value);
88 public final void writeShort(final int value) throws IOException {
89 ensureHeaderWritten();
90 output.writeShort(value);
94 public final void writeChar(final int value) throws IOException {
95 ensureHeaderWritten();
96 output.writeChar(value);
100 public final void writeInt(final int value) throws IOException {
101 ensureHeaderWritten();
102 output.writeInt(value);
106 public final void writeLong(final long value) throws IOException {
107 ensureHeaderWritten();
108 output.writeLong(value);
112 public final void writeFloat(final float value) throws IOException {
113 ensureHeaderWritten();
114 output.writeFloat(value);
118 public final void writeDouble(final double value) throws IOException {
119 ensureHeaderWritten();
120 output.writeDouble(value);
124 public final void writeBytes(final String str) throws IOException {
125 ensureHeaderWritten();
126 output.writeBytes(str);
130 public final void writeChars(final String str) throws IOException {
131 ensureHeaderWritten();
132 output.writeChars(str);
136 public final void writeUTF(final String str) throws IOException {
137 ensureHeaderWritten();
138 output.writeUTF(str);
142 public final void writeQName(final QName qname) throws IOException {
143 ensureHeaderWritten();
144 writeQNameInternal(qname);
148 public final void writeNormalizedNode(final NormalizedNode node) throws IOException {
149 ensureHeaderWritten();
150 if (normalizedNodeWriter == null) {
151 normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(this);
153 normalizedNodeWriter.write(node);
157 public final void writePathArgument(final PathArgument pathArgument) throws IOException {
158 ensureHeaderWritten();
159 writePathArgumentInternal(pathArgument);
163 public final void writeYangInstanceIdentifier(final YangInstanceIdentifier identifier) throws IOException {
164 ensureHeaderWritten();
165 writeYangInstanceIdentifierInternal(identifier);
170 public final void writeSchemaPath(final SchemaPath path) throws IOException {
171 writeSchemaNodeIdentifier(path.isAbsolute(), path.getPathFromRoot());
175 public final void writeSchemaNodeIdentifier(final SchemaNodeIdentifier path) throws IOException {
176 writeSchemaNodeIdentifier(path instanceof Absolute, path.getNodeIdentifiers());
179 private void writeSchemaNodeIdentifier(final boolean absolute, final Iterable<QName> qnames) throws IOException {
180 ensureHeaderWritten();
182 output.writeBoolean(absolute);
183 output.writeInt(Iterables.size(qnames));
184 for (QName qname : qnames) {
185 writeQNameInternal(qname);
190 public final void close() throws IOException {
195 public void flush() throws IOException {
196 if (output instanceof OutputStream) {
197 ((OutputStream)output).flush();
202 public final boolean startAnydataNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
203 // FIXME: We do not support anydata nodes of any kind, yet
207 abstract short streamVersion();
209 abstract void writeQNameInternal(@NonNull QName qname) throws IOException;
211 abstract void writePathArgumentInternal(PathArgument pathArgument) throws IOException;
213 abstract void writeYangInstanceIdentifierInternal(YangInstanceIdentifier identifier) throws IOException;