Fixup previous patch and sprinkle more @Serial annotations.
Change-Id: I74414861197bb417dadc445ebc3fc2703a97ea4d
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
import java.io.DataInput;
import java.io.IOException;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.AbstractRequestProxy;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
*/
abstract class AbstractLocalHistoryRequestProxy<T extends LocalHistoryRequest<T>>
extends AbstractRequestProxy<LocalHistoryIdentifier, T> {
+ @Serial
private static final long serialVersionUID = 1L;
protected AbstractLocalHistoryRequestProxy() {
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.Request;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
*/
public abstract class AbstractLocalTransactionRequest<T extends AbstractLocalTransactionRequest<T>>
extends TransactionRequest<T> {
+ @Serial
private static final long serialVersionUID = 1L;
AbstractLocalTransactionRequest(final TransactionIdentifier identifier, final long sequence,
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataInput;
*/
abstract class AbstractReadPathTransactionRequestProxyV1<T extends AbstractReadPathTransactionRequest<T>>
extends AbstractReadTransactionRequestProxyV1<T> {
+ @Serial
private static final long serialVersionUID = 1L;
private YangInstanceIdentifier path;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
*/
abstract class AbstractReadTransactionRequestProxyV1<T extends AbstractReadTransactionRequest<T>>
extends AbstractTransactionRequestProxy<T> {
+ @Serial
private static final long serialVersionUID = 1L;
+
private boolean snapshotOnly;
protected AbstractReadTransactionRequestProxyV1() {
import java.io.DataInput;
import java.io.IOException;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.AbstractRequestProxy;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
*/
abstract class AbstractTransactionRequestProxy<T extends TransactionRequest<T>>
extends AbstractRequestProxy<TransactionIdentifier, T> {
+ @Serial
private static final long serialVersionUID = 1L;
- protected AbstractTransactionRequestProxy() {
+ AbstractTransactionRequestProxy() {
// For Externalizable
}
import java.io.DataInput;
import java.io.IOException;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.AbstractSuccessProxy;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
*/
abstract class AbstractTransactionSuccessProxy<T extends TransactionSuccess<T>>
extends AbstractSuccessProxy<TransactionIdentifier, T> {
+ @Serial
private static final long serialVersionUID = 1L;
- protected AbstractTransactionSuccessProxy() {
+ AbstractTransactionSuccessProxy() {
// For Externalizable
}
import akka.actor.ActorRef;
import com.google.common.base.MoreObjects.ToStringHelper;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.AbstractRequestProxy;
import org.opendaylight.controller.cluster.access.concepts.ClientIdentifier;
* It also includes request stream sequencing information.
*/
public final class ConnectClientRequest extends Request<ClientIdentifier, ConnectClientRequest> {
+ @Serial
private static final long serialVersionUID = 1L;
private final ABIVersion minVersion;
import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.collect.ImmutableList;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import java.io.Serial;
import java.util.List;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
* fail, the client can try accessing the provided alternates.
*/
public final class ConnectClientSuccess extends RequestSuccess<ClientIdentifier, ConnectClientSuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
private final @NonNull ImmutableList<ActorSelection> alternates;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
+import java.io.Serial;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.controller.cluster.access.concepts.AbstractSuccessProxy;
* @author Robert Varga
*/
final class ConnectClientSuccessProxyV1 extends AbstractSuccessProxy<ClientIdentifier, ConnectClientSuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
private List<ActorSelection> alternates;
ConnectClientSuccessProxyV1(final ConnectClientSuccess success) {
super(success);
- this.alternates = success.getAlternates();
- this.backend = success.getBackend();
- this.maxMessages = success.getMaxMessages();
+ alternates = success.getAlternates();
+ backend = success.getBackend();
+ maxMessages = success.getMaxMessages();
// We are ignoring the DataTree, it is not serializable anyway
}
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
/**
* @author Robert Varga
*/
final class CreateLocalHistoryRequestProxyV1 extends AbstractLocalHistoryRequestProxy<CreateLocalHistoryRequest> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
/**
* @author Robert Varga
*/
final class DestroyLocalHistoryRequestProxyV1 extends AbstractLocalHistoryRequestProxy<DestroyLocalHistoryRequest> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
*/
final class ExistsTransactionRequestProxyV1 extends
AbstractReadPathTransactionRequestProxyV1<ExistsTransactionRequest> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
* @author Robert Varga
*/
final class ExistsTransactionSuccessProxyV1 extends AbstractTransactionSuccessProxy<ExistsTransactionSuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
+
private boolean exists;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
ExistsTransactionSuccessProxyV1(final ExistsTransactionSuccess request) {
super(request);
- this.exists = request.getExists();
+ exists = request.getExists();
}
@Override
import akka.actor.ActorRef;
import com.google.common.base.Preconditions;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
*/
public final class IncrementTransactionSequenceRequest extends
AbstractReadTransactionRequest<IncrementTransactionSequenceRequest> {
+ @Serial
private static final long serialVersionUID = 1L;
private final long increment;
*/
package org.opendaylight.controller.cluster.access.commands;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
*/
final class IncrementTransactionSequenceSuccessProxyV1
extends AbstractTransactionSuccessProxy<IncrementTransactionSequenceSuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
import java.io.DataInput;
import java.io.IOException;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.AbstractRequestFailureProxy;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
*/
final class LocalHistoryFailureProxyV1 extends
AbstractRequestFailureProxy<LocalHistoryIdentifier, LocalHistoryFailure> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
*/
package org.opendaylight.controller.cluster.access.commands;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.AbstractSuccessProxy;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
* Success class for {@link RequestSuccess}es involving a specific local history.
*/
public final class LocalHistorySuccess extends RequestSuccess<LocalHistoryIdentifier, LocalHistorySuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
public LocalHistorySuccess(final LocalHistoryIdentifier target, final long sequence) {
import java.io.DataInput;
import java.io.IOException;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.AbstractSuccessProxy;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
* @author Robert Varga
*/
final class LocalHistorySuccessProxyV1 extends AbstractSuccessProxy<LocalHistoryIdentifier, LocalHistorySuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
+import java.io.Serial;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
* @author Robert Varga
*/
final class ModifyTransactionRequestProxyV1 extends AbstractTransactionRequestProxy<ModifyTransactionRequest> {
+ @Serial
private static final long serialVersionUID = 1L;
private List<TransactionModification> modifications;
ModifyTransactionRequestProxyV1(final ModifyTransactionRequest request) {
super(request);
- this.modifications = requireNonNull(request.getModifications());
- this.protocol = request.getPersistenceProtocol();
- this.streamVersion = request.getVersion().getStreamVersion();
+ modifications = requireNonNull(request.getModifications());
+ protocol = request.getPersistenceProtocol();
+ streamVersion = request.getVersion().getStreamVersion();
}
@Override
*/
package org.opendaylight.controller.cluster.access.commands;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
* @author Robert Varga
*/
final class ModifyTransactionSuccessProxyV1 extends AbstractTransactionSuccessProxy<ModifyTransactionSuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
/**
* @author Robert Varga
*/
final class PurgeLocalHistoryRequestProxyV1 extends AbstractLocalHistoryRequestProxy<PurgeLocalHistoryRequest> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
* @author Robert Varga
*/
final class ReadTransactionRequestProxyV1 extends AbstractReadPathTransactionRequestProxyV1<ReadTransactionRequest> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
+import java.io.Serial;
import java.util.Optional;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
* @author Robert Varga
*/
final class ReadTransactionSuccessProxyV1 extends AbstractTransactionSuccessProxy<ReadTransactionSuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
private Optional<NormalizedNode> data;
ReadTransactionSuccessProxyV1(final ReadTransactionSuccess request) {
super(request);
- this.data = request.getData();
- this.streamVersion = request.getVersion().getStreamVersion();
+ data = request.getData();
+ streamVersion = request.getVersion().getStreamVersion();
}
@Override
*/
package org.opendaylight.controller.cluster.access.commands;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
* serialization format.
*/
final class SkipTransactionsResponseProxyV1 extends AbstractTransactionSuccessProxy<SkipTransactionsResponse> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
* @author Robert Varga
*/
final class TransactionAbortRequestProxyV1 extends AbstractTransactionRequestProxy<TransactionAbortRequest> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
*/
package org.opendaylight.controller.cluster.access.commands;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* @author Robert Varga
*/
public final class TransactionAbortSuccess extends TransactionSuccess<TransactionAbortSuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
public TransactionAbortSuccess(final TransactionIdentifier identifier, final long sequence) {
*/
package org.opendaylight.controller.cluster.access.commands;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
* @author Robert Varga
*/
final class TransactionAbortSuccessProxyV1 extends AbstractTransactionSuccessProxy<TransactionAbortSuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
*/
package org.opendaylight.controller.cluster.access.commands;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* @author Robert Varga
*/
public final class TransactionCanCommitSuccess extends TransactionSuccess<TransactionCanCommitSuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
public TransactionCanCommitSuccess(final TransactionIdentifier identifier, final long sequence) {
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
* @author Robert Varga
*/
final class TransactionCanCommitSuccessProxyV1 extends AbstractTransactionSuccessProxy<TransactionCanCommitSuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
*/
package org.opendaylight.controller.cluster.access.commands;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* @author Robert Varga
*/
public final class TransactionCommitSuccess extends TransactionSuccess<TransactionCommitSuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
public TransactionCommitSuccess(final TransactionIdentifier identifier, final long sequence) {
*/
package org.opendaylight.controller.cluster.access.commands;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
* @author Robert Varga
*/
final class TransactionCommitSuccessProxyV1 extends AbstractTransactionSuccessProxy<TransactionCommitSuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
* @author Robert Varga
*/
final class TransactionDoCommitRequestProxyV1 extends AbstractTransactionRequestProxy<TransactionDoCommitRequest> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
import java.io.DataInput;
import java.io.IOException;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.AbstractRequestFailureProxy;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* @author Robert Varga
*/
final class TransactionFailureProxyV1 extends AbstractRequestFailureProxy<TransactionIdentifier, TransactionFailure> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
* @author Robert Varga
*/
final class TransactionPreCommitRequestProxyV1 extends AbstractTransactionRequestProxy<TransactionPreCommitRequest> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
*/
package org.opendaylight.controller.cluster.access.commands;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* @author Robert Varga
*/
public final class TransactionPreCommitSuccess extends TransactionSuccess<TransactionPreCommitSuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
public TransactionPreCommitSuccess(final TransactionIdentifier identifier, final long sequence) {
*/
package org.opendaylight.controller.cluster.access.commands;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
* @author Robert Varga
*/
final class TransactionPreCommitSuccessProxyV1 extends AbstractTransactionSuccessProxy<TransactionPreCommitSuccess> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
* @author Robert Varga
*/
final class TransactionPurgeRequestProxyV1 extends AbstractTransactionRequestProxy<TransactionPurgeRequest> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
*/
package org.opendaylight.controller.cluster.access.commands;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* @author Robert Varga
*/
public final class TransactionPurgeResponse extends TransactionSuccess<TransactionPurgeResponse> {
+ @Serial
private static final long serialVersionUID = 1L;
public TransactionPurgeResponse(final TransactionIdentifier identifier, final long sequence) {
*/
package org.opendaylight.controller.cluster.access.commands;
+import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
* @author Robert Varga
*/
final class TransactionPurgeResponseProxyV1 extends AbstractTransactionSuccessProxy<TransactionPurgeResponse> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
+import java.io.Serial;
import org.opendaylight.yangtools.concepts.WritableObjects;
abstract class AbstractEnvelopeProxy<T extends Message<?, ?>> implements Externalizable {
+ @Serial
private static final long serialVersionUID = 1L;
private T message;
@SuppressWarnings("checkstyle:hiddenField")
abstract Envelope<T> createEnvelope(T wrappedNessage, long sessionId, long txSequence);
+ @Serial
final Object readResolve() {
return createEnvelope(message, sessionId, txSequence);
}
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
+import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
import org.opendaylight.yangtools.concepts.WritableObjects;
* @param <C> Message class
*/
abstract class AbstractMessageProxy<T extends WritableIdentifier, C extends Message<T, C>> implements Externalizable {
+ @Serial
private static final long serialVersionUID = 1L;
+
private T target;
private long sequence;
sequence = WritableObjects.readLong(in);
}
+ @Serial
protected final Object readResolve() {
return verifyNotNull(createMessage(target, sequence));
}
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
+import java.io.Serial;
import org.opendaylight.yangtools.concepts.WritableObjects;
abstract class AbstractResponseEnvelopeProxy<T extends Response<?, ?>> extends AbstractEnvelopeProxy<T> {
+ @Serial
private static final long serialVersionUID = 1L;
private long executionTimeNanos;
*/
package org.opendaylight.controller.cluster.access.concepts;
+import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
*/
abstract class AbstractResponseProxy<T extends WritableIdentifier, C extends Response<T, C>>
extends AbstractMessageProxy<T, C> {
+ @Serial
private static final long serialVersionUID = 1L;
protected AbstractResponseProxy() {
generation = WritableObjects.readLong(in);
}
+ @Serial
private Object readResolve() {
return new ClientIdentifier(frontendId, generation);
}
.toString();
}
+ @Serial
private Object writeReplace() {
return new Proxy(frontendId, generation);
}
import static java.util.Objects.requireNonNull;
import com.google.common.base.MoreObjects;
+import java.io.Serial;
import java.io.Serializable;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Immutable;
public abstract class Envelope<T extends Message<?, ?>> implements Immutable, Serializable {
+ @Serial
private static final long serialVersionUID = 1L;
private final @NonNull T message;
.add("txSequence", Long.toHexString(txSequence)).add("message", message).toString();
}
+ @Serial
final Object writeReplace() {
return createProxy();
}
*/
package org.opendaylight.controller.cluster.access.concepts;
+import java.io.Serial;
+
public final class FailureEnvelope extends ResponseEnvelope<RequestFailure<?, ?>> {
+ @Serial
private static final long serialVersionUID = 1L;
public FailureEnvelope(final RequestFailure<?, ?> message, final long sessionId, final long txSequence,
*/
package org.opendaylight.controller.cluster.access.concepts;
+import java.io.Serial;
+
final class FailureEnvelopeProxy extends AbstractResponseEnvelopeProxy<RequestFailure<?, ?>> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to be
clientType = FrontendType.readFrom(in);
}
+ @Serial
private Object readResolve() {
return new FrontendIdentifier(memberName, clientType);
}
@Override
public boolean equals(final Object obj) {
- if (this == obj) {
- return true;
- }
- if (!(obj instanceof FrontendIdentifier other)) {
- return false;
- }
-
- return memberName.equals(other.memberName) && clientType.equals(other.clientType);
+ return this == obj || obj instanceof FrontendIdentifier other && memberName.equals(other.memberName)
+ && clientType.equals(other.clientType);
}
public @NonNull String toPersistentId() {
return toPersistentId();
}
+ @Serial
private Object writeReplace() {
return new Proxy(memberName, clientType);
}
private static final class Proxy implements Externalizable {
@Serial
private static final long serialVersionUID = 1L;
+
private byte[] serialized;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
in.readFully(serialized);
}
+ @Serial
private Object readResolve() {
// TODO: consider caching instances here
return new FrontendType(new String(serialized, StandardCharsets.UTF_8), serialized);
return local;
}
+ @Serial
Object writeReplace() {
return new Proxy(getSerialized());
}
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
+import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
import org.opendaylight.yangtools.concepts.WritableObjects;
* - a {@link ClientIdentifier}, which uniquely identifies a single instantiation of a particular frontend
* - an unsigned long, which uniquely identifies the history on the backend
* - an unsigned long cookie, assigned by the client and meaningless on the backend, which just reflects it back
- *
- * @author Robert Varga
*/
public final class LocalHistoryIdentifier implements WritableIdentifier {
/*
* compatibility.
*/
private static final class Proxy implements Externalizable {
+ @Serial
private static final long serialVersionUID = 1L;
+
private ClientIdentifier clientId;
private long historyId;
private long cookie;
cookie = WritableObjects.readSecondLong(in, header);
}
+ @Serial
private Object readResolve() {
return new LocalHistoryIdentifier(clientId, historyId, cookie);
}
}
+ @Serial
private static final long serialVersionUID = 1L;
+
private final @NonNull ClientIdentifier clientId;
private final long historyId;
private final long cookie;
if (this == obj) {
return true;
}
- if (!(obj instanceof LocalHistoryIdentifier)) {
+ if (!(obj instanceof LocalHistoryIdentifier other)) {
return false;
}
- final LocalHistoryIdentifier other = (LocalHistoryIdentifier) obj;
return historyId == other.historyId && cookie == other.cookie && clientId.equals(other.clientId);
}
.add("cookie", Long.toUnsignedString(cookie, 16)).toString();
}
+ @Serial
private Object writeReplace() {
return new Proxy(clientId, historyId, cookie);
}
in.readFully(serialized);
}
+ @Serial
private Object readResolve() {
// TODO: consider caching instances here
return new MemberName(new String(serialized, StandardCharsets.UTF_8), serialized);
return local;
}
+ @Serial
Object writeReplace() {
return new Proxy(getSerialized());
}
return switch (toVersion) {
case BORON, NEON_SR2, SODIUM_SR1, MAGNESIUM -> verifyNotNull(cloneAsVersion(toVersion));
- case TEST_PAST_VERSION, TEST_FUTURE_VERSION ->
- throw new IllegalArgumentException("Unhandled ABI version " + toVersion);
default -> throw new IllegalArgumentException("Unhandled ABI version " + toVersion);
};
}
*/
abstract @NonNull AbstractMessageProxy<T, C> externalizableProxy(@NonNull ABIVersion reqVersion);
+ @Serial
protected final Object writeReplace() {
return externalizableProxy(version);
}
package org.opendaylight.controller.cluster.access.concepts;
import akka.actor.ActorRef;
+import java.io.Serial;
public final class RequestEnvelope extends Envelope<Request<?, ?>> {
+ @Serial
private static final long serialVersionUID = 1L;
public RequestEnvelope(final Request<?, ?> message, final long sessionId, final long txSequence) {
*/
package org.opendaylight.controller.cluster.access.concepts;
+import java.io.Serial;
+
final class RequestEnvelopeProxy extends AbstractEnvelopeProxy<Request<?, ?>> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
package org.opendaylight.controller.cluster.access.concepts;
import com.google.common.base.Preconditions;
+import java.io.Serial;
public abstract class ResponseEnvelope<T extends Response<?, ?>> extends Envelope<T> {
+ @Serial
private static final long serialVersionUID = 1L;
private final long executionTimeNanos;
*/
package org.opendaylight.controller.cluster.access.concepts;
+import java.io.Serial;
+
public final class SuccessEnvelope extends ResponseEnvelope<RequestSuccess<?, ?>> {
+ @Serial
private static final long serialVersionUID = 1L;
public SuccessEnvelope(final RequestSuccess<?, ?> message, final long sessionId, final long txSequence,
*/
package org.opendaylight.controller.cluster.access.concepts;
+import java.io.Serial;
+
final class SuccessEnvelopeProxy extends AbstractResponseEnvelopeProxy<RequestSuccess<?, ?>> {
+ @Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
transactionId = WritableObjects.readLong(in);
}
+ @Serial
private Object readResolve() {
return new TransactionIdentifier(historyId, transactionId);
}
return toShortString();
}
+ @Serial
private Object writeReplace() {
return new Proxy(historyId, transactionId);
}
Code Review / controller.git / commitdiff