*/
package org.opendaylight.controller.cluster.datastore.persisted;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.io.Externalizable;
import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.controller.cluster.raft.persisted.Snapshot;
/**
*
* @author Thomas Pantelis
*/
-public class DatastoreSnapshot implements Serializable {
- private static final long serialVersionUID = 1L;
+public final class DatastoreSnapshot implements Serializable {
+ interface SerialForm extends Externalizable {
- private static final class Proxy implements Externalizable {
- private static final long serialVersionUID = 1L;
+ DatastoreSnapshot datastoreSnapshot();
- private DatastoreSnapshot datastoreSnapshot;
+ Object readResolve();
- // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
- // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
- @SuppressWarnings("checkstyle:RedundantModifier")
- public Proxy() {
- // For Externalizable
- }
+ void resolveTo(@NonNull DatastoreSnapshot newDatastoreSnapshot);
+
+ @Override
+ default void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
+ final var type = (String)in.readObject();
+ final var snapshot = (ShardManagerSnapshot) in.readObject();
+
+ final int size = in.readInt();
+ var localShardSnapshots = new ArrayList<ShardSnapshot>(size);
+ for (int i = 0; i < size; i++) {
+ localShardSnapshots.add((ShardSnapshot) in.readObject());
+ }
- Proxy(final DatastoreSnapshot datastoreSnapshot) {
- this.datastoreSnapshot = datastoreSnapshot;
+ resolveTo(new DatastoreSnapshot(type, snapshot, localShardSnapshots));
}
@Override
- public void writeExternal(ObjectOutput out) throws IOException {
+ default void writeExternal(final ObjectOutput out) throws IOException {
+ final var datastoreSnapshot = datastoreSnapshot();
out.writeObject(datastoreSnapshot.type);
out.writeObject(datastoreSnapshot.shardManagerSnapshot);
out.writeObject(shardSnapshot);
}
}
+ }
- @Override
- public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- String type = (String)in.readObject();
- ShardManagerSnapshot shardManagerSnapshot = (ShardManagerSnapshot) in.readObject();
+ private static final class Proxy implements SerialForm {
+ private static final long serialVersionUID = 1L;
- int size = in.readInt();
- List<ShardSnapshot> shardSnapshots = new ArrayList<>(size);
- for (int i = 0; i < size; i++) {
- shardSnapshots.add((ShardSnapshot) in.readObject());
- }
+ private DatastoreSnapshot datastoreSnapshot;
- datastoreSnapshot = new DatastoreSnapshot(type, shardManagerSnapshot, shardSnapshots);
+ // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
+ // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public Proxy() {
+ // For Externalizable
}
- private Object readResolve() {
+ @Override
+ public DatastoreSnapshot datastoreSnapshot() {
return datastoreSnapshot;
}
+
+ @Override
+ public void resolveTo(final DatastoreSnapshot newDatastoreSnapshot) {
+ datastoreSnapshot = requireNonNull(newDatastoreSnapshot);
+ }
+
+ @Override
+ public Object readResolve() {
+ return verifyNotNull(datastoreSnapshot);
+ }
}
- private final String type;
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private final @NonNull String type;
private final ShardManagerSnapshot shardManagerSnapshot;
- private final List<ShardSnapshot> shardSnapshots;
+ private final @NonNull ImmutableList<ShardSnapshot> shardSnapshots;
- public DatastoreSnapshot(@Nonnull String type, @Nullable ShardManagerSnapshot shardManagerSnapshot,
- @Nonnull List<ShardSnapshot> shardSnapshots) {
- this.type = Preconditions.checkNotNull(type);
+ public DatastoreSnapshot(final @NonNull String type, final @Nullable ShardManagerSnapshot shardManagerSnapshot,
+ final @NonNull List<ShardSnapshot> shardSnapshots) {
+ this.type = requireNonNull(type);
this.shardManagerSnapshot = shardManagerSnapshot;
- this.shardSnapshots = ImmutableList.copyOf(Preconditions.checkNotNull(shardSnapshots));
+ this.shardSnapshots = ImmutableList.copyOf(shardSnapshots);
}
- @Nonnull
- public String getType() {
+ public @NonNull String getType() {
return type;
}
- @Nullable
- public ShardManagerSnapshot getShardManagerSnapshot() {
+ public @Nullable ShardManagerSnapshot getShardManagerSnapshot() {
return shardManagerSnapshot;
}
- @Nonnull
- public List<ShardSnapshot> getShardSnapshots() {
+ public @NonNull List<ShardSnapshot> getShardSnapshots() {
return shardSnapshots;
}
- @SuppressWarnings("static-method")
+ @java.io.Serial
private Object writeReplace() {
- return new Proxy(this);
+ return new DS(this);
}
- public static class ShardSnapshot implements Serializable {
- private static final long serialVersionUID = 1L;
+ public static final class ShardSnapshot implements Serializable {
+ interface SerialForm extends Externalizable {
+
+ ShardSnapshot shardSnapshot();
+
+ Object readResolve();
+
+ void resolveTo(String name, Snapshot snapshot);
+
+ @Override
+ default void writeExternal(final ObjectOutput out) throws IOException {
+ final var shardSnapshot = shardSnapshot();
+ out.writeObject(shardSnapshot.name);
+ out.writeObject(shardSnapshot.snapshot);
+ }
- private static final class Proxy implements Externalizable {
+ @Override
+ default void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
+ resolveTo((String) in.readObject(), (Snapshot) in.readObject());
+ }
+ }
+
+ private static final class Proxy implements SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private ShardSnapshot shardSnapshot;
// For Externalizable
}
- Proxy(final ShardSnapshot shardSnapshot) {
- this.shardSnapshot = shardSnapshot;
- }
-
@Override
- public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(shardSnapshot.name);
- out.writeObject(shardSnapshot.snapshot);
+ public ShardSnapshot shardSnapshot() {
+ return shardSnapshot;
}
@Override
- public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- shardSnapshot = new ShardSnapshot((String)in.readObject(), (Snapshot) in.readObject());
+ public void resolveTo(final String name, final Snapshot snapshot) {
+ shardSnapshot = new ShardSnapshot(name, snapshot);
}
- private Object readResolve() {
- return shardSnapshot;
+ @Override
+ public Object readResolve() {
+ return verifyNotNull(shardSnapshot);
}
}
- private final String name;
- private final Snapshot snapshot;
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private final @NonNull String name;
+ private final @NonNull Snapshot snapshot;
- public ShardSnapshot(@Nonnull String name, @Nonnull Snapshot snapshot) {
- this.name = Preconditions.checkNotNull(name);
- this.snapshot = Preconditions.checkNotNull(snapshot);
+ public ShardSnapshot(final @NonNull String name, final @NonNull Snapshot snapshot) {
+ this.name = requireNonNull(name);
+ this.snapshot = requireNonNull(snapshot);
}
- @Nonnull
- public String getName() {
+ public @NonNull String getName() {
return name;
}
- @Nonnull
- public Snapshot getSnapshot() {
+ public @NonNull Snapshot getSnapshot() {
return snapshot;
}
- @SuppressWarnings("static-method")
+ @java.io.Serial
private Object writeReplace() {
- return new Proxy(this);
+ return new DSS(this);
}
}
}
Code Review / controller.git / blobdiff