--- /dev/null
+/*
+ * Copyright (c) 2014, 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.datastore.node.utils.stream;
+
+import com.google.common.annotations.Beta;
+import java.io.DataInput;
+import java.io.IOException;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;;
+
+/**
+ * Interface for reading {@link NormalizedNode}s, {@link YangInstanceIdentifier}s and {@link PathArgument}s.
+ */
+@Beta
+public interface NormalizedNodeDataInput extends DataInput {
+ /**
+ * Read a normalized node from the reader.
+ *
+ * @return Next node from the stream, or null if end of stream has been reached.
+ * @throws IOException if an error occurs
+ * @throws IllegalStateException if the dictionary has been detached
+ */
+ NormalizedNode<?, ?> readNormalizedNode() throws IOException;
+
+ YangInstanceIdentifier readYangInstanceIdentifier() throws IOException;
+
+ PathArgument readPathArgument() throws IOException;
+}
--- /dev/null
+/*
+ * Copyright (c) 2014, 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.datastore.node.utils.stream;
+
+import com.google.common.annotations.Beta;
+import java.io.DataOutput;
+import java.io.IOException;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;;
+
+/**
+ * Interface for emitting {@link NormalizedNode}s, {@link YangInstanceIdentifier}s and {@link PathArgument}s.
+ */
+@Beta
+public interface NormalizedNodeDataOutput extends DataOutput {
+ void writeNormalizedNode(NormalizedNode<?, ?> normalizedNode) throws IOException;
+ void writePathArgument(PathArgument pathArgument) throws IOException;
+ void writeYangInstanceIdentifier(YangInstanceIdentifier identifier) throws IOException;
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.datastore.node.utils.stream;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+import javax.annotation.Nonnull;
+
+public final class NormalizedNodeInputOutput {
+ private NormalizedNodeInputOutput() {
+ throw new UnsupportedOperationException();
+ }
+
+ public static NormalizedNodeDataInput newDataInput(@Nonnull final DataInput input) throws IOException {
+ return new NormalizedNodeInputStreamReader(input);
+ }
+
+ public static NormalizedNodeDataOutput newDataOutput(@Nonnull final DataOutput output) throws IOException {
+ return new NormalizedNodeOutputStreamWriter(output);
+ }
+}
*
*/
-public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamReader {
+public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, NormalizedNodeStreamReader {
private static final Logger LOG = LoggerFactory.getLogger(NormalizedNodeInputStreamReader.class);
input = new DataInputStream(stream);
}
+ /**
+ * @deprecated Use {@link NormalizedNodeInputOutput#newDataInput(DataInput)} instead.
+ */
+ @Deprecated
public NormalizedNodeInputStreamReader(final DataInput input) {
this.input = Preconditions.checkNotNull(input);
}
return new String(bytes, StandardCharsets.UTF_8);
}
+ @Override
public YangInstanceIdentifier readYangInstanceIdentifier() throws IOException {
readSignatureMarkerAndVersionIfNeeded();
return readYangInstanceIdentifierInternal();
return children;
}
+ @Override
public PathArgument readPathArgument() throws IOException {
// read Type
int type = input.readByte();
}
return builder;
}
+
+ @Override
+ public void readFully(byte[] b) throws IOException {
+ readSignatureMarkerAndVersionIfNeeded();
+ input.readFully(b);
+ }
+
+ @Override
+ public void readFully(byte[] b, int off, int len) throws IOException {
+ readSignatureMarkerAndVersionIfNeeded();
+ input.readFully(b, off, len);
+ }
+
+ @Override
+ public int skipBytes(int n) throws IOException {
+ readSignatureMarkerAndVersionIfNeeded();
+ return input.skipBytes(n);
+ }
+
+ @Override
+ public boolean readBoolean() throws IOException {
+ readSignatureMarkerAndVersionIfNeeded();
+ return input.readBoolean();
+ }
+
+ @Override
+ public byte readByte() throws IOException {
+ readSignatureMarkerAndVersionIfNeeded();
+ return input.readByte();
+ }
+
+ @Override
+ public int readUnsignedByte() throws IOException {
+ readSignatureMarkerAndVersionIfNeeded();
+ return input.readUnsignedByte();
+ }
+
+ @Override
+ public short readShort() throws IOException {
+ readSignatureMarkerAndVersionIfNeeded();
+ return input.readShort();
+ }
+
+ @Override
+ public int readUnsignedShort() throws IOException {
+ readSignatureMarkerAndVersionIfNeeded();
+ return input.readUnsignedShort();
+ }
+
+ @Override
+ public char readChar() throws IOException {
+ readSignatureMarkerAndVersionIfNeeded();
+ return input.readChar();
+ }
+
+ @Override
+ public int readInt() throws IOException {
+ readSignatureMarkerAndVersionIfNeeded();
+ return input.readInt();
+ }
+
+ @Override
+ public long readLong() throws IOException {
+ readSignatureMarkerAndVersionIfNeeded();
+ return input.readLong();
+ }
+
+ @Override
+ public float readFloat() throws IOException {
+ readSignatureMarkerAndVersionIfNeeded();
+ return input.readFloat();
+ }
+
+ @Override
+ public double readDouble() throws IOException {
+ readSignatureMarkerAndVersionIfNeeded();
+ return input.readDouble();
+ }
+
+ @Override
+ public String readLine() throws IOException {
+ readSignatureMarkerAndVersionIfNeeded();
+ return input.readLine();
+ }
+
+ @Override
+ public String readUTF() throws IOException {
+ readSignatureMarkerAndVersionIfNeeded();
+ return input.readUTF();
+ }
}
*
*/
-public class NormalizedNodeOutputStreamWriter implements NormalizedNodeStreamWriter {
+public class NormalizedNodeOutputStreamWriter implements NormalizedNodeDataOutput, NormalizedNodeStreamWriter {
private static final Logger LOG = LoggerFactory.getLogger(NormalizedNodeOutputStreamWriter.class);
this((DataOutput) new DataOutputStream(Preconditions.checkNotNull(stream)));
}
- public NormalizedNodeOutputStreamWriter(DataOutput output) {
+ /**
+ * @deprecated Use {@link NormalizedNodeInputOutput#newDataOutput(DataOutput)} instead.
+ */
+ @Deprecated
+ public NormalizedNodeOutputStreamWriter(final DataOutput output) {
this.output = Preconditions.checkNotNull(output);
}
return normalizedNodeWriter;
}
+ @Override
public void writeNormalizedNode(NormalizedNode<?, ?> node) throws IOException {
writeSignatureMarkerAndVersionIfNeeded();
normalizedNodeWriter().write(node);
}
}
+ @Override
public void writeYangInstanceIdentifier(YangInstanceIdentifier identifier) throws IOException {
writeSignatureMarkerAndVersionIfNeeded();
writeYangInstanceIdentifierInternal(identifier);
}
}
+ @Override
public void writePathArgument(YangInstanceIdentifier.PathArgument pathArgument) throws IOException {
byte type = PathArgumentTypes.getSerializablePathArgumentType(pathArgument);
output.writeByte(type);
switch(type) {
- case PathArgumentTypes.NODE_IDENTIFIER :
+ case PathArgumentTypes.NODE_IDENTIFIER:
YangInstanceIdentifier.NodeIdentifier nodeIdentifier =
(YangInstanceIdentifier.NodeIdentifier) pathArgument;
break;
}
}
+
+ @Override
+ public void write(int b) throws IOException {
+ writeSignatureMarkerAndVersionIfNeeded();
+ output.write(b);
+ }
+
+ @Override
+ public void write(byte[] b) throws IOException {
+ writeSignatureMarkerAndVersionIfNeeded();
+ output.write(b);
+ }
+
+ @Override
+ public void write(byte[] b, int off, int len) throws IOException {
+ writeSignatureMarkerAndVersionIfNeeded();
+ output.write(b, off, len);
+ }
+
+ @Override
+ public void writeBoolean(boolean v) throws IOException {
+ writeSignatureMarkerAndVersionIfNeeded();
+ output.writeBoolean(v);
+ }
+
+ @Override
+ public void writeByte(int v) throws IOException {
+ writeSignatureMarkerAndVersionIfNeeded();
+ output.writeByte(v);
+ }
+
+ @Override
+ public void writeShort(int v) throws IOException {
+ writeSignatureMarkerAndVersionIfNeeded();
+ output.writeShort(v);
+ }
+
+ @Override
+ public void writeChar(int v) throws IOException {
+ writeSignatureMarkerAndVersionIfNeeded();
+ output.writeChar(v);
+ }
+
+ @Override
+ public void writeInt(int v) throws IOException {
+ writeSignatureMarkerAndVersionIfNeeded();
+ output.writeInt(v);
+ }
+
+ @Override
+ public void writeLong(long v) throws IOException {
+ writeSignatureMarkerAndVersionIfNeeded();
+ output.writeLong(v);
+ }
+
+ @Override
+ public void writeFloat(float v) throws IOException {
+ writeSignatureMarkerAndVersionIfNeeded();
+ output.writeFloat(v);
+ }
+
+ @Override
+ public void writeDouble(double v) throws IOException {
+ writeSignatureMarkerAndVersionIfNeeded();
+ output.writeDouble(v);
+ }
+
+ @Override
+ public void writeBytes(String s) throws IOException {
+ writeSignatureMarkerAndVersionIfNeeded();
+ output.writeBytes(s);
+ }
+
+ @Override
+ public void writeChars(String s) throws IOException {
+ writeSignatureMarkerAndVersionIfNeeded();
+ output.writeChars(s);
+ }
+
+ @Override
+ public void writeUTF(String s) throws IOException {
+ writeSignatureMarkerAndVersionIfNeeded();
+ output.writeUTF(s);
+ }
}
package org.opendaylight.controller.cluster.datastore.node.utils.stream;
-import java.io.IOException;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-
/**
* Interface for a class that can read serialized NormalizedNode instances from a stream.
+ *
+ * @deprecated Use {@link NormalizedNodeDataInput} instead.
*/
-public interface NormalizedNodeStreamReader {
-
- NormalizedNode<?, ?> readNormalizedNode() throws IOException;
+public interface NormalizedNodeStreamReader extends NormalizedNodeDataInput {
}
import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
import com.google.protobuf.GeneratedMessage.GeneratedExtension;
-import java.io.DataInput;
-import java.io.DataOutput;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
+import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeDataInput;
+import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeDataOutput;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeInputStreamReader;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeOutputStreamWriter;
import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload;
this.serialized = Preconditions.checkNotNull(serialized);
}
- private static void writeChildren(final NormalizedNodeOutputStreamWriter writer, final DataOutput out,
+ private static void writeChildren(final NormalizedNodeDataOutput out,
final Collection<DataTreeCandidateNode> children) throws IOException {
out.writeInt(children.size());
for (DataTreeCandidateNode child : children) {
- writeNode(writer, out, child);
+ writeNode(out, child);
}
}
- private static void writeNode(final NormalizedNodeOutputStreamWriter writer, final DataOutput out,
- final DataTreeCandidateNode node) throws IOException {
+ private static void writeNode(final NormalizedNodeDataOutput out, final DataTreeCandidateNode node)
+ throws IOException {
switch (node.getModificationType()) {
case APPEARED:
out.writeByte(APPEARED);
- writer.writePathArgument(node.getIdentifier());
- writeChildren(writer, out, node.getChildNodes());
+ out.writePathArgument(node.getIdentifier());
+ writeChildren(out, node.getChildNodes());
break;
case DELETE:
out.writeByte(DELETE);
- writer.writePathArgument(node.getIdentifier());
+ out.writePathArgument(node.getIdentifier());
break;
case DISAPPEARED:
out.writeByte(DISAPPEARED);
- writer.writePathArgument(node.getIdentifier());
- writeChildren(writer, out, node.getChildNodes());
+ out.writePathArgument(node.getIdentifier());
+ writeChildren(out, node.getChildNodes());
break;
case SUBTREE_MODIFIED:
out.writeByte(SUBTREE_MODIFIED);
- writer.writePathArgument(node.getIdentifier());
- writeChildren(writer, out, node.getChildNodes());
+ out.writePathArgument(node.getIdentifier());
+ writeChildren(out, node.getChildNodes());
break;
case WRITE:
out.writeByte(WRITE);
- writer.writeNormalizedNode(node.getDataAfter().get());
+ out.writeNormalizedNode(node.getDataAfter().get());
break;
case UNMODIFIED:
out.writeByte(UNMODIFIED);
}
}
- static DataTreeCandidatePayload create(DataTreeCandidate candidate) {
+ static DataTreeCandidatePayload create(final DataTreeCandidate candidate) {
final ByteArrayDataOutput out = ByteStreams.newDataOutput();
try (final NormalizedNodeOutputStreamWriter writer = new NormalizedNodeOutputStreamWriter(out)) {
writer.writeYangInstanceIdentifier(candidate.getRootPath());
final DataTreeCandidateNode node = candidate.getRootNode();
switch (node.getModificationType()) {
case APPEARED:
- out.writeByte(APPEARED);
- writeChildren(writer, out, node.getChildNodes());
+ writer.writeByte(APPEARED);
+ writeChildren(writer, node.getChildNodes());
break;
case DELETE:
- out.writeByte(DELETE);
+ writer.writeByte(DELETE);
break;
case DISAPPEARED:
- out.writeByte(DISAPPEARED);
- writeChildren(writer, out, node.getChildNodes());
+ writer.writeByte(DISAPPEARED);
+ writeChildren(writer, node.getChildNodes());
break;
case SUBTREE_MODIFIED:
- out.writeByte(SUBTREE_MODIFIED);
- writeChildren(writer, out, node.getChildNodes());
+ writer.writeByte(SUBTREE_MODIFIED);
+ writeChildren(writer, node.getChildNodes());
break;
case UNMODIFIED:
- out.writeByte(UNMODIFIED);
+ writer.writeByte(UNMODIFIED);
break;
case WRITE:
- out.writeByte(WRITE);
+ writer.writeByte(WRITE);
writer.writeNormalizedNode(node.getDataAfter().get());
break;
default:
throw new IllegalArgumentException("Unhandled node type " + node.getModificationType());
}
- writer.close();
} catch (IOException e) {
throw new IllegalArgumentException(String.format("Failed to serialize candidate %s", candidate), e);
}
return new DataTreeCandidatePayload(out.toByteArray());
}
- private static Collection<DataTreeCandidateNode> readChildren(final NormalizedNodeInputStreamReader reader,
- final DataInput in) throws IOException {
+ private static Collection<DataTreeCandidateNode> readChildren(final NormalizedNodeDataInput in) throws IOException {
final int size = in.readInt();
if (size != 0) {
final Collection<DataTreeCandidateNode> ret = new ArrayList<>(size);
for (int i = 0; i < size; ++i) {
- final DataTreeCandidateNode child = readNode(reader, in);
+ final DataTreeCandidateNode child = readNode(in);
if (child != null) {
ret.add(child);
}
}
private static DataTreeCandidateNode readModifiedNode(final ModificationType type,
- final NormalizedNodeInputStreamReader reader, final DataInput in) throws IOException {
+ final NormalizedNodeDataInput in) throws IOException {
- final PathArgument identifier = reader.readPathArgument();
- final Collection<DataTreeCandidateNode> children = readChildren(reader, in);
+ final PathArgument identifier = in.readPathArgument();
+ final Collection<DataTreeCandidateNode> children = readChildren(in);
if (children.isEmpty()) {
LOG.debug("Modified node {} does not have any children, not instantiating it", identifier);
return null;
}
}
- private static DataTreeCandidateNode readNode(final NormalizedNodeInputStreamReader reader,
- final DataInput in) throws IOException {
+ private static DataTreeCandidateNode readNode(final NormalizedNodeDataInput in) throws IOException {
final byte type = in.readByte();
switch (type) {
case APPEARED:
- return readModifiedNode(ModificationType.APPEARED, reader, in);
+ return readModifiedNode(ModificationType.APPEARED, in);
case DELETE:
- return DeletedDataTreeCandidateNode.create(reader.readPathArgument());
+ return DeletedDataTreeCandidateNode.create(in.readPathArgument());
case DISAPPEARED:
- return readModifiedNode(ModificationType.DISAPPEARED, reader, in);
+ return readModifiedNode(ModificationType.DISAPPEARED, in);
case SUBTREE_MODIFIED:
- return readModifiedNode(ModificationType.SUBTREE_MODIFIED, reader, in);
+ return readModifiedNode(ModificationType.SUBTREE_MODIFIED, in);
case UNMODIFIED:
return null;
case WRITE:
- return DataTreeCandidateNodes.fromNormalizedNode(reader.readNormalizedNode());
+ return DataTreeCandidateNodes.fromNormalizedNode(in.readNormalizedNode());
default:
throw new IllegalArgumentException("Unhandled node type " + type);
}
}
private static DataTreeCandidate parseCandidate(final ByteArrayDataInput in) throws IOException {
- final NormalizedNodeInputStreamReader reader = new NormalizedNodeInputStreamReader(in);
+ final NormalizedNodeDataInput reader = new NormalizedNodeInputStreamReader(in);
final YangInstanceIdentifier rootPath = reader.readYangInstanceIdentifier();
- final byte type = in.readByte();
+ final byte type = reader.readByte();
final DataTreeCandidateNode rootNode;
switch (type) {
rootNode = DeletedDataTreeCandidateNode.create();
break;
case SUBTREE_MODIFIED:
- rootNode = ModifiedDataTreeCandidateNode.create(readChildren(reader, in));
+ rootNode = ModifiedDataTreeCandidateNode.create(readChildren(reader));
break;
case WRITE:
rootNode = DataTreeCandidateNodes.fromNormalizedNode(reader.readNormalizedNode());
import java.io.IOException;
import org.opendaylight.controller.cluster.datastore.node.NormalizedNodeToNodeCodec;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.InvalidNormalizedNodeStreamException;
+import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeDataInput;
+import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeDataOutput;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeInputStreamReader;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeOutputStreamWriter;
import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
void apply(T instance, YangInstanceIdentifier path, NormalizedNode<?, ?> node);
}
- private static NormalizedNodeOutputStreamWriter streamWriter(DataOutput out) throws IOException {
+ private static NormalizedNodeDataOutput streamWriter(DataOutput out) throws IOException {
NormalizedNodeOutputStreamWriter streamWriter = REUSABLE_WRITER_TL.get();
if(streamWriter == null) {
streamWriter = new NormalizedNodeOutputStreamWriter(out);
return streamWriter;
}
- private static NormalizedNodeInputStreamReader streamReader(DataInput in) throws IOException {
+ private static NormalizedNodeDataInput streamReader(DataInput in) throws IOException {
NormalizedNodeInputStreamReader streamWriter = REUSABLE_READER_TL.get();
if(streamWriter == null) {
streamWriter = new NormalizedNodeInputStreamReader(in);
Preconditions.checkNotNull(path);
Preconditions.checkNotNull(node);
try {
- NormalizedNodeOutputStreamWriter streamWriter = streamWriter(out);
+ NormalizedNodeDataOutput streamWriter = streamWriter(out);
streamWriter.writeNormalizedNode(node);
streamWriter.writeYangInstanceIdentifier(path);
} catch (IOException e) {
public static <T> void deserializePathAndNode(DataInput in, T instance, Applier<T> applier) {
try {
- NormalizedNodeInputStreamReader streamReader = streamReader(in);
+ NormalizedNodeDataInput streamReader = streamReader(in);
NormalizedNode<?, ?> node = streamReader.readNormalizedNode();
YangInstanceIdentifier path = streamReader.readYangInstanceIdentifier();
applier.apply(instance, path, node);
try {
out.writeBoolean(node != null);
if(node != null) {
- NormalizedNodeOutputStreamWriter streamWriter = streamWriter(out);
+ NormalizedNodeDataOutput streamWriter = streamWriter(out);
streamWriter.writeNormalizedNode(node);
}
} catch (IOException e) {
private static NormalizedNode<?, ?> tryDeserializeNormalizedNode(DataInput in) throws IOException {
boolean present = in.readBoolean();
if(present) {
- NormalizedNodeInputStreamReader streamReader = streamReader(in);
+ NormalizedNodeDataInput streamReader = streamReader(in);
return streamReader.readNormalizedNode();
}
public static void serializePath(YangInstanceIdentifier path, DataOutput out) {
Preconditions.checkNotNull(path);
try {
- NormalizedNodeOutputStreamWriter streamWriter = streamWriter(out);
+ NormalizedNodeDataOutput streamWriter = streamWriter(out);
streamWriter.writeYangInstanceIdentifier(path);
} catch (IOException e) {
throw new IllegalArgumentException(String.format("Error serializing path %s", path), e);
public static YangInstanceIdentifier deserializePath(DataInput in) {
try {
- NormalizedNodeInputStreamReader streamReader = streamReader(in);
+ NormalizedNodeDataInput streamReader = streamReader(in);
return streamReader.readYangInstanceIdentifier();
} catch (IOException e) {
throw new IllegalArgumentException("Error deserializing path", e);
Code Review / controller.git / commitdiff