import java.io.DataOutput;
import java.io.DataOutputStream;
import java.io.IOException;
+import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public final class SerializationUtils {
@Deprecated
public static final ThreadLocal<NormalizedNodeDataOutput> REUSABLE_WRITER_TL = new ThreadLocal<>();
+ @Deprecated
public static final ThreadLocal<NormalizedNodeDataInput> REUSABLE_READER_TL = new ThreadLocal<>();
private SerializationUtils() {
+
}
+ @FunctionalInterface
public interface Applier<T> {
void apply(T instance, YangInstanceIdentifier path, NormalizedNode<?, ?> node);
}
return streamWriter;
}
+ @Deprecated
private static NormalizedNodeDataInput streamReader(final DataInput in) throws IOException {
NormalizedNodeDataInput streamReader = REUSABLE_READER_TL.get();
if (streamReader == null) {
}
}
+ @Deprecated
public static <T> void deserializePathAndNode(final DataInput in, final T instance, final Applier<T> applier) {
try {
NormalizedNodeDataInput streamReader = streamReader(in);
return null;
}
+ @Deprecated
public static NormalizedNode<?, ?> deserializeNormalizedNode(final DataInput in) {
try {
return tryDeserializeNormalizedNode(in);
}
}
+ @Deprecated
public static NormalizedNode<?, ?> deserializeNormalizedNode(final byte [] bytes) {
try {
return tryDeserializeNormalizedNode(new DataInputStream(new ByteArrayInputStream(bytes)));
}
}
+ public static Optional<NormalizedNode<?, ?>> readNormalizedNode(final DataInput in) throws IOException {
+ if (!in.readBoolean()) {
+ return Optional.empty();
+ }
+ return Optional.of(NormalizedNodeInputOutput.newDataInput(in).readNormalizedNode());
+ }
+
@Deprecated
public static void serializeNormalizedNode(final NormalizedNode<?, ?> node, final DataOutput out) {
try {
}
}
+ public static YangInstanceIdentifier readPath(final DataInput in) throws IOException {
+ return NormalizedNodeInputOutput.newDataInput(in).readYangInstanceIdentifier();
+ }
+
public static void writePath(final DataOutput out, final @NonNull YangInstanceIdentifier path)
throws IOException {
try (NormalizedNodeDataOutput stream = NormalizedNodeInputOutput.newDataOutput(out)) {
}
}
+ public static <T> void readNodeAndPath(final DataInput in, final T instance, final Applier<T> applier)
+ throws IOException {
+ final NormalizedNodeDataInput stream = NormalizedNodeInputOutput.newDataInput(in);
+ NormalizedNode<?, ?> node = stream.readNormalizedNode();
+ YangInstanceIdentifier path = stream.readYangInstanceIdentifier();
+ applier.apply(instance, path, node);
+ }
+
public static void writeNodeAndPath(final DataOutput out, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> node) throws IOException {
try (NormalizedNodeDataOutput stream = NormalizedNodeInputOutput.newDataOutput(out)) {
}
}
+ public static <T> void readPathAndNode(final DataInput in, final T instance, final Applier<T> applier)
+ throws IOException {
+ final NormalizedNodeDataInput stream = NormalizedNodeInputOutput.newDataInput(in);
+ YangInstanceIdentifier path = stream.readYangInstanceIdentifier();
+ NormalizedNode<?, ?> node = stream.readNormalizedNode();
+ applier.apply(instance, path, node);
+ }
+
public static void writePathAndNode(final DataOutput out, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> node) throws IOException {
try (NormalizedNodeDataOutput stream = NormalizedNodeInputOutput.newDataOutput(out)) {
}
}
+ @Deprecated
public static YangInstanceIdentifier deserializePath(final DataInput in) {
try {
NormalizedNodeDataInput streamReader = streamReader(in);
.build();
SerializationUtils.writePath(out, path);
final YangInstanceIdentifier deserialized =
- SerializationUtils.deserializePath(new DataInputStream(new ByteArrayInputStream(bos.toByteArray())));
+ SerializationUtils.readPath(new DataInputStream(new ByteArrayInputStream(bos.toByteArray())));
Assert.assertEquals(path, deserialized);
}
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) -> {
+ SerializationUtils.readNodeAndPath(in, applierCalled, (instance, deserializedPath, deserializedNode) -> {
Assert.assertEquals(path, deserializedPath);
Assert.assertEquals(node, deserializedNode);
applierCalled.set(true);
}
@Override
- public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
+ public final void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
super.readExternal(in);
- path = SerializationUtils.deserializePath(in);
+ path = SerializationUtils.readPath(in);
}
@Override
@Override
public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
super.readExternal(in);
- normalizedNode = SerializationUtils.deserializeNormalizedNode(in);
+ normalizedNode = SerializationUtils.readNormalizedNode(in).orElse(null);
}
@Override
@Override
public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
dataTreeChangeListenerPath = (ActorRef) in.readObject();
- path = SerializationUtils.deserializePath(in);
+ path = SerializationUtils.readPath(in);
registerOnAllInstances = in.readBoolean();
}
}
@Override
- public void readExternal(final ObjectInput in) {
- setPath(SerializationUtils.deserializePath(in));
+ public void readExternal(final ObjectInput in) throws IOException {
+ setPath(SerializationUtils.readPath(in));
}
@Override
@Deprecated
public static DeleteModification fromStream(final ObjectInput in, final short version) {
DeleteModification mod = new DeleteModification(version);
- mod.readExternal(in);
+ try {
+ mod.readExternal(in);
+ } catch (IOException e) {
+ throw new IllegalArgumentException("Error deserializing DeleteModification", e);
+ }
return mod;
}
@Deprecated
public static MergeModification fromStream(final ObjectInput in, final short version) {
MergeModification mod = new MergeModification(version);
- mod.readExternal(in);
+ try {
+ mod.readExternal(in);
+ } catch (IOException e) {
+ throw new IllegalArgumentException("Error deserializing MergeModification", e);
+ }
return mod;
}
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.SerializationUtils;
-import org.opendaylight.controller.cluster.datastore.node.utils.stream.SerializationUtils.Applier;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
}
@Override
- public void readExternal(final ObjectInput in) {
- SerializationUtils.deserializePathAndNode(in, this, APPLIER);
+ public void readExternal(final ObjectInput in) throws IOException {
+ SerializationUtils.readNodeAndPath(in, this, (instance, path, node) -> {
+ instance.setPath(path);
+ instance.data = node;
+ });
}
@Override
@Deprecated
public static WriteModification fromStream(final ObjectInput in, final short version) {
WriteModification mod = new WriteModification(version);
- mod.readExternal(in);
+ try {
+ mod.readExternal(in);
+ } catch (IOException e) {
+ throw new IllegalArgumentException("Error deserializing WriteModification", e);
+ }
return mod;
}
out.writeNormalizedNode(data);
out.writeYangInstanceIdentifier(getPath());
}
-
- private static final Applier<WriteModification> APPLIER = (instance, path, node) -> {
- instance.setPath(path);
- instance.data = node;
- };
}
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
}
metadata = metaBuilder.build();
- rootNode = Verify.verifyNotNull(SerializationUtils.deserializeNormalizedNode(in));
+ rootNode = SerializationUtils.readNormalizedNode(in).get();
}
private Object readResolve() {
@Override
public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
+ // FIXME: QName is a WritableObject
QName qname = (QName) in.readObject();
- executeRpc = new ExecuteRpc(SerializationUtils.deserializeNormalizedNode(in), qname);
+ executeRpc = new ExecuteRpc(SerializationUtils.readNormalizedNode(in).orElse(null), qname);
}
private Object readResolve() {
}
@Override
- public void readExternal(final ObjectInput in) {
- rpcResponse = new RpcResponse(SerializationUtils.deserializeNormalizedNode(in));
+ public void readExternal(final ObjectInput in) throws IOException {
+ rpcResponse = new RpcResponse(SerializationUtils.readNormalizedNode(in).orElse(null));
}
private Object readResolve() {
Code Review / controller.git / commitdiff