opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/AbstractNormalizedNodeDataOutput.java

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.controller.cluster.datastore.node.utils.stream;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  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;
  25
  26 /**
  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.
  30  *
  31  * <p>
  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.
  34  */
  35 abstract class AbstractNormalizedNodeDataOutput implements NormalizedNodeDataOutput, NormalizedNodeStreamWriter {
  36     // Visible for subclasses
  37     final DataOutput output;
  38
  39     private NormalizedNodeWriter normalizedNodeWriter;
  40     private boolean headerWritten;
  41
  42     AbstractNormalizedNodeDataOutput(final DataOutput output) {
  43         this.output = requireNonNull(output);
  44     }
  45
  46
  47     private void ensureHeaderWritten() throws IOException {
  48         if (!headerWritten) {
  49             output.writeByte(TokenTypes.SIGNATURE_MARKER);
  50             output.writeShort(streamVersion());
  51             headerWritten = true;
  52         }
  53     }
  54
  55     @Override
  56     public final void write(final int value) throws IOException {
  57         ensureHeaderWritten();
  58         output.write(value);
  59     }
  60
  61     @Override
  62     public final void write(final byte[] bytes) throws IOException {
  63         ensureHeaderWritten();
  64         output.write(bytes);
  65     }
  66
  67     @Override
  68     public final void write(final byte[] bytes, final int off, final int len) throws IOException {
  69         ensureHeaderWritten();
  70         output.write(bytes, off, len);
  71     }
  72
  73     @Override
  74     public final void writeBoolean(final boolean value) throws IOException {
  75         ensureHeaderWritten();
  76         output.writeBoolean(value);
  77     }
  78
  79     @Override
  80     public final void writeByte(final int value) throws IOException {
  81         ensureHeaderWritten();
  82         output.writeByte(value);
  83     }
  84
  85     @Override
  86     public final void writeShort(final int value) throws IOException {
  87         ensureHeaderWritten();
  88         output.writeShort(value);
  89     }
  90
  91     @Override
  92     public final void writeChar(final int value) throws IOException {
  93         ensureHeaderWritten();
  94         output.writeChar(value);
  95     }
  96
  97     @Override
  98     public final void writeInt(final int value) throws IOException {
  99         ensureHeaderWritten();
 100         output.writeInt(value);
 101     }
 102
 103     @Override
 104     public final void writeLong(final long value) throws IOException {
 105         ensureHeaderWritten();
 106         output.writeLong(value);
 107     }
 108
 109     @Override
 110     public final void writeFloat(final float value) throws IOException {
 111         ensureHeaderWritten();
 112         output.writeFloat(value);
 113     }
 114
 115     @Override
 116     public final void writeDouble(final double value) throws IOException {
 117         ensureHeaderWritten();
 118         output.writeDouble(value);
 119     }
 120
 121     @Override
 122     public final void writeBytes(final String str) throws IOException {
 123         ensureHeaderWritten();
 124         output.writeBytes(str);
 125     }
 126
 127     @Override
 128     public final void writeChars(final String str) throws IOException {
 129         ensureHeaderWritten();
 130         output.writeChars(str);
 131     }
 132
 133     @Override
 134     public final void writeUTF(final String str) throws IOException {
 135         ensureHeaderWritten();
 136         output.writeUTF(str);
 137     }
 138
 139     @Override
 140     public final void writeQName(final QName qname) throws IOException {
 141         ensureHeaderWritten();
 142         writeQNameInternal(qname);
 143     }
 144
 145     @Override
 146     public final void writeNormalizedNode(final NormalizedNode<?, ?> node) throws IOException {
 147         ensureHeaderWritten();
 148         if (normalizedNodeWriter == null) {
 149             normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(this);
 150         }
 151         normalizedNodeWriter.write(node);
 152     }
 153
 154     @Override
 155     public final void writePathArgument(final PathArgument pathArgument) throws IOException {
 156         ensureHeaderWritten();
 157         writePathArgumentInternal(pathArgument);
 158     }
 159
 160     @Override
 161     public final void writeYangInstanceIdentifier(final YangInstanceIdentifier identifier) throws IOException {
 162         ensureHeaderWritten();
 163         writeYangInstanceIdentifierInternal(identifier);
 164     }
 165
 166     @Override
 167     public final void writeSchemaPath(final SchemaPath path) throws IOException {
 168         ensureHeaderWritten();
 169
 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);
 175         }
 176     }
 177
 178     @Override
 179     public final void close() throws IOException {
 180         flush();
 181     }
 182
 183     @Override
 184     public void flush() throws IOException {
 185         if (output instanceof OutputStream) {
 186             ((OutputStream)output).flush();
 187         }
 188     }
 189
 190     @Override
 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
 193         return false;
 194     }
 195
 196     abstract short streamVersion();
 197
 198     abstract void writeQNameInternal(@NonNull QName qname) throws IOException;
 199
 200     abstract void writePathArgumentInternal(PathArgument pathArgument) throws IOException;
 201
 202     abstract void writeYangInstanceIdentifierInternal(YangInstanceIdentifier identifier) throws IOException;
 203 }