import com.google.common.annotations.Beta;
import java.io.DataOutput;
import java.io.IOException;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
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;
*/
@Beta
public interface NormalizedNodeDataOutput extends AutoCloseable, DataOutput {
- void writeNormalizedNode(NormalizedNode<?, ?> normalizedNode) throws IOException;
+ void writeNormalizedNode(@NonNull NormalizedNode<?, ?> normalizedNode) throws IOException;
void writePathArgument(PathArgument pathArgument) throws IOException;
@Override
void close() throws IOException;
+
+ default void writeOptionalNormalizedNode(final @Nullable NormalizedNode<?, ?> normalizedNode) throws IOException {
+ if (normalizedNode != null) {
+ writeBoolean(true);
+ writeNormalizedNode(normalizedNode);
+ } else {
+ writeBoolean(false);
+ }
+ }
}
*/
package org.opendaylight.controller.cluster.datastore.node.utils.stream;
-import com.google.common.base.Preconditions;
import java.io.ByteArrayInputStream;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.DataOutput;
import java.io.IOException;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
* @author Thomas Pantelis
*/
public final class SerializationUtils {
- public static final ThreadLocal<NormalizedNodeDataOutput> REUSABLE_WRITER_TL = new ThreadLocal<>();
public static final ThreadLocal<NormalizedNodeDataInput> REUSABLE_READER_TL = new ThreadLocal<>();
private SerializationUtils() {
void apply(T instance, YangInstanceIdentifier path, NormalizedNode<?, ?> node);
}
- private static NormalizedNodeDataOutput streamWriter(DataOutput out) {
- NormalizedNodeDataOutput streamWriter = REUSABLE_WRITER_TL.get();
- if (streamWriter == null) {
- streamWriter = NormalizedNodeInputOutput.newDataOutput(out);
- }
-
- return streamWriter;
- }
-
- private static NormalizedNodeDataInput streamReader(DataInput in) throws IOException {
+ private static NormalizedNodeDataInput streamReader(final DataInput in) throws IOException {
NormalizedNodeDataInput streamReader = REUSABLE_READER_TL.get();
if (streamReader == null) {
streamReader = NormalizedNodeInputOutput.newDataInput(in);
return streamReader;
}
- public static void serializePathAndNode(YangInstanceIdentifier path, NormalizedNode<?, ?> node,
- DataOutput out) {
- Preconditions.checkNotNull(path);
- Preconditions.checkNotNull(node);
- try {
- NormalizedNodeDataOutput streamWriter = streamWriter(out);
- streamWriter.writeNormalizedNode(node);
- streamWriter.writeYangInstanceIdentifier(path);
- } catch (IOException e) {
- throw new IllegalArgumentException(String.format("Error serializing path %s and Node %s",
- path, node), e);
- }
- }
-
- public static <T> void deserializePathAndNode(DataInput in, T instance, Applier<T> applier) {
+ public static <T> void deserializePathAndNode(final DataInput in, final T instance, final Applier<T> applier) {
try {
NormalizedNodeDataInput streamReader = streamReader(in);
NormalizedNode<?, ?> node = streamReader.readNormalizedNode();
}
}
- private static NormalizedNode<?, ?> tryDeserializeNormalizedNode(DataInput in) throws IOException {
+ private static NormalizedNode<?, ?> tryDeserializeNormalizedNode(final DataInput in) throws IOException {
boolean present = in.readBoolean();
if (present) {
NormalizedNodeDataInput streamReader = streamReader(in);
return null;
}
- public static NormalizedNode<?, ?> deserializeNormalizedNode(DataInput in) {
+ public static NormalizedNode<?, ?> deserializeNormalizedNode(final DataInput in) {
try {
return tryDeserializeNormalizedNode(in);
} catch (IOException e) {
}
}
- public static NormalizedNode<?, ?> deserializeNormalizedNode(byte [] bytes) {
+ public static NormalizedNode<?, ?> deserializeNormalizedNode(final byte [] bytes) {
try {
return tryDeserializeNormalizedNode(new DataInputStream(new ByteArrayInputStream(bytes)));
} catch (IOException e) {
}
}
- public static void serializeNormalizedNode(NormalizedNode<?, ?> node, DataOutput out) {
- try {
- out.writeBoolean(node != null);
- if (node != null) {
- NormalizedNodeDataOutput streamWriter = streamWriter(out);
- streamWriter.writeNormalizedNode(node);
+ public static void writeNormalizedNode(final DataOutput out, final @Nullable NormalizedNode<?, ?> node)
+ throws IOException {
+ if (node != null) {
+ out.writeBoolean(true);
+
+ try (NormalizedNodeDataOutput stream = NormalizedNodeInputOutput.newDataOutput(out)) {
+ stream.writeNormalizedNode(node);
}
- } catch (IOException e) {
- throw new IllegalArgumentException(String.format("Error serializing NormalizedNode %s",
- node), e);
+ } else {
+ out.writeBoolean(false);
}
}
- public static void serializePath(YangInstanceIdentifier path, DataOutput out) {
- Preconditions.checkNotNull(path);
- try {
- NormalizedNodeDataOutput streamWriter = streamWriter(out);
- streamWriter.writeYangInstanceIdentifier(path);
- } catch (IOException e) {
- throw new IllegalArgumentException(String.format("Error serializing path %s", path), e);
+ public static void writePath(final DataOutput out, final @NonNull YangInstanceIdentifier path)
+ throws IOException {
+ try (NormalizedNodeDataOutput stream = NormalizedNodeInputOutput.newDataOutput(out)) {
+ stream.writeYangInstanceIdentifier(path);
+ }
+ }
+
+ public static void writeNodeAndPath(final DataOutput out, final YangInstanceIdentifier path,
+ final NormalizedNode<?, ?> node) throws IOException {
+ try (NormalizedNodeDataOutput stream = NormalizedNodeInputOutput.newDataOutput(out)) {
+ stream.writeNormalizedNode(node);
+ stream.writeYangInstanceIdentifier(path);
+ }
+ }
+
+ public static void writePathAndNode(final DataOutput out, final YangInstanceIdentifier path,
+ final NormalizedNode<?, ?> node) throws IOException {
+ try (NormalizedNodeDataOutput stream = NormalizedNodeInputOutput.newDataOutput(out)) {
+ stream.writeYangInstanceIdentifier(path);
+ stream.writeNormalizedNode(node);
}
}
- public static YangInstanceIdentifier deserializePath(DataInput in) {
+ public static YangInstanceIdentifier deserializePath(final DataInput in) {
try {
NormalizedNodeDataInput streamReader = streamReader(in);
return streamReader.readYangInstanceIdentifier();
import java.io.DataInputStream;
import java.io.DataOutput;
import java.io.DataOutputStream;
+import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.Set;
private static final QName CONTAINER_Q_NAME = QName.create("ns-1", "2017-03-17", "container1");
@Test
- public void testSerializeDeserializeNodes() {
+ public void testSerializeDeserializeNodes() throws IOException {
final NormalizedNode<?, ?> normalizedNode = createNormalizedNode();
final byte[] bytes = serializeNormalizedNode(normalizedNode);
Assert.assertEquals(normalizedNode, SerializationUtils.deserializeNormalizedNode(bytes));
-
}
@Test
}
@Test
- public void testSerializeDeserializePath() {
+ public void testSerializeDeserializePath() throws IOException {
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
final DataOutput out = new DataOutputStream(bos);
final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
.node(listId("list1", "keyName1", "keyValue1"))
.node(leafSetId("leafSer1", "leafSetValue1"))
.build();
- SerializationUtils.serializePath(path, out);
+ SerializationUtils.writePath(out, path);
final YangInstanceIdentifier deserialized =
SerializationUtils.deserializePath(new DataInputStream(new ByteArrayInputStream(bos.toByteArray())));
Assert.assertEquals(path, deserialized);
}
@Test
- public void testSerializeDeserializePathAndNode() {
+ public void testSerializeDeserializePathAndNode() throws IOException {
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
final DataOutput out = new DataOutputStream(bos);
final NormalizedNode<?, ?> node = createNormalizedNode();
final YangInstanceIdentifier path = YangInstanceIdentifier.create(id("container1"));
- SerializationUtils.serializePathAndNode(path, node, out);
+ SerializationUtils.writeNodeAndPath(out, path, node);
final DataInputStream in = new DataInputStream(new ByteArrayInputStream(bos.toByteArray()));
final AtomicBoolean applierCalled = new AtomicBoolean(false);
SerializationUtils.deserializePathAndNode(in, applierCalled, (instance, deserializedPath, deserializedNode) -> {
Assert.assertTrue(applierCalled.get());
}
- private static byte[] serializeNormalizedNode(final NormalizedNode<?, ?> node) {
+ private static byte[] serializeNormalizedNode(final NormalizedNode<?, ?> node) throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
- SerializationUtils.serializeNormalizedNode(node, new DataOutputStream(bos));
+ SerializationUtils.writeNormalizedNode(new DataOutputStream(bos), node);
return bos.toByteArray();
}
}
@Override
- public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
super.readExternal(in);
path = SerializationUtils.deserializePath(in);
}
@Override
- public void writeExternal(ObjectOutput out) throws IOException {
+ public void writeExternal(final ObjectOutput out) throws IOException {
super.writeExternal(out);
- SerializationUtils.serializePath(path, out);
+ SerializationUtils.writePath(out, path);
}
- public AbstractRead<T> asVersion(short version) {
+ public AbstractRead<T> asVersion(final short version) {
return version == getVersion() ? this : newInstance(version);
}
public ReadDataReply() {
}
- public ReadDataReply(NormalizedNode<?, ?> normalizedNode, short version) {
+ public ReadDataReply(final NormalizedNode<?, ?> normalizedNode, final short version) {
super(version);
this.normalizedNode = normalizedNode;
}
}
@Override
- public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
super.readExternal(in);
normalizedNode = SerializationUtils.deserializeNormalizedNode(in);
}
@Override
- public void writeExternal(ObjectOutput out) throws IOException {
+ public void writeExternal(final ObjectOutput out) throws IOException {
super.writeExternal(out);
- SerializationUtils.serializeNormalizedNode(normalizedNode, out);
+ SerializationUtils.writeNormalizedNode(out, normalizedNode);
}
- public static ReadDataReply fromSerializable(Object serializable) {
+ public static ReadDataReply fromSerializable(final Object serializable) {
return (ReadDataReply) serializable;
}
- public static boolean isSerializedType(Object message) {
+ public static boolean isSerializedType(final Object message) {
return message instanceof ReadDataReply;
}
}
*/
package org.opendaylight.controller.cluster.datastore.messages;
+import static java.util.Objects.requireNonNull;
+
import akka.actor.ActorPath;
import akka.actor.ActorRef;
-import com.google.common.base.Preconditions;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
*/
public final class RegisterDataTreeChangeListener implements Externalizable {
private static final long serialVersionUID = 1L;
+
private ActorRef dataTreeChangeListenerPath;
private YangInstanceIdentifier path;
private boolean registerOnAllInstances;
public RegisterDataTreeChangeListener(final YangInstanceIdentifier path, final ActorRef dataTreeChangeListenerPath,
final boolean registerOnAllInstances) {
- this.path = Preconditions.checkNotNull(path);
- this.dataTreeChangeListenerPath = Preconditions.checkNotNull(dataTreeChangeListenerPath);
+ this.path = requireNonNull(path);
+ this.dataTreeChangeListenerPath = requireNonNull(dataTreeChangeListenerPath);
this.registerOnAllInstances = registerOnAllInstances;
}
@Override
public void writeExternal(final ObjectOutput out) throws IOException {
out.writeObject(dataTreeChangeListenerPath);
- SerializationUtils.serializePath(path, out);
+ SerializationUtils.writePath(out, path);
out.writeBoolean(registerOnAllInstances);
}
}
@Override
- public void writeExternal(final ObjectOutput out) {
- SerializationUtils.serializePath(getPath(), out);
+ public void writeExternal(final ObjectOutput out) throws IOException {
+ SerializationUtils.writePath(out, getPath());
}
@Override
}
@Override
- public void writeExternal(final ObjectOutput out) {
- SerializationUtils.serializePathAndNode(getPath(), data, out);
+ public void writeExternal(final ObjectOutput out) throws IOException {
+ SerializationUtils.writeNodeAndPath(out, getPath(), data);
}
public static WriteModification fromStream(final NormalizedNodeDataInput in, final short version)
return new WriteModification(version, path, node);
}
+ @Override
public void writeTo(final NormalizedNodeDataOutput out) throws IOException {
// FIXME: this should be inverted, as the path helps receivers in establishment of context
out.writeNormalizedNode(data);
out.writeObject(m);
}
- SerializationUtils.serializeNormalizedNode(rootNode, out);
+ SerializationUtils.writeNormalizedNode(out, rootNode);
}
@Override
public Proxy() {
}
- Proxy(ExecuteRpc executeRpc) {
+ Proxy(final ExecuteRpc executeRpc) {
this.executeRpc = executeRpc;
}
@Override
- public void writeExternal(ObjectOutput out) throws IOException {
+ public void writeExternal(final ObjectOutput out) throws IOException {
+ // FIXME: QName is a WritableObject
out.writeObject(executeRpc.getRpc());
- SerializationUtils.serializeNormalizedNode(executeRpc.getInputNormalizedNode(), out);
+ SerializationUtils.writeNormalizedNode(out, executeRpc.getInputNormalizedNode());
}
@Override
- public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
QName qname = (QName) in.readObject();
executeRpc = new ExecuteRpc(SerializationUtils.deserializeNormalizedNode(in), qname);
}
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.Externalizable;
+import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.Serializable;
public Proxy() {
}
- Proxy(RpcResponse rpcResponse) {
+ Proxy(final RpcResponse rpcResponse) {
this.rpcResponse = rpcResponse;
}
@Override
- public void writeExternal(ObjectOutput out) {
- SerializationUtils.serializeNormalizedNode(rpcResponse.getResultNormalizedNode(), out);
+ public void writeExternal(final ObjectOutput out) throws IOException {
+ SerializationUtils.writeNormalizedNode(out, rpcResponse.getResultNormalizedNode());
}
@Override
- public void readExternal(ObjectInput in) {
+ public void readExternal(final ObjectInput in) {
rpcResponse = new RpcResponse(SerializationUtils.deserializeNormalizedNode(in));
}