*/
package org.opendaylight.controller.cluster.access.concepts;
-import com.google.common.annotations.Beta;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
+import java.io.DataInput;
+import java.io.DataOutput;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
-import org.opendaylight.yangtools.concepts.Identifier;
+import java.io.Serial;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.cds.types.rev191024.ClientGeneration;
+import org.opendaylight.yangtools.concepts.WritableIdentifier;
+import org.opendaylight.yangtools.concepts.WritableObjects;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* A cluster-wide unique identifier of a frontend instance. This identifier discerns between individual incarnations
*
* @author Robert Varga
*/
-@Beta
-public final class ClientIdentifier<T extends FrontendType> implements Identifier {
- private static final class Proxy<T extends FrontendType> implements Externalizable {
+public final class ClientIdentifier implements WritableIdentifier {
+ private static final class Proxy implements Externalizable {
+ @Serial
private static final long serialVersionUID = 1L;
- private FrontendIdentifier<T> frontendId;
+
+ private FrontendIdentifier frontendId;
private long generation;
+ // checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
+ // be able to create instances via reflection.
+ @SuppressWarnings("checkstyle:RedundantModifier")
public Proxy() {
// Needed for Externalizable
}
- Proxy(final FrontendIdentifier<T> frontendId, final long generation) {
- this.frontendId = Preconditions.checkNotNull(frontendId);
+ Proxy(final FrontendIdentifier frontendId, final long generation) {
+ this.frontendId = requireNonNull(frontendId);
this.generation = generation;
}
@Override
- public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(frontendId);
- out.writeLong(generation);
+ public void writeExternal(final ObjectOutput out) throws IOException {
+ frontendId.writeTo(out);
+ WritableObjects.writeLong(out, generation);
}
- @SuppressWarnings("unchecked")
@Override
- public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- frontendId = (FrontendIdentifier<T>) in.readObject();
- generation = in.readLong();
+ public void readExternal(final ObjectInput in) throws IOException {
+ frontendId = FrontendIdentifier.readFrom(in);
+ generation = WritableObjects.readLong(in);
}
+ @Serial
private Object readResolve() {
- return new ClientIdentifier<>(frontendId, generation);
+ return new ClientIdentifier(frontendId, generation);
}
}
+ @Serial
private static final long serialVersionUID = 1L;
- private final FrontendIdentifier<T> frontendId;
+
+ private final @NonNull FrontendIdentifier frontendId;
private final long generation;
- ClientIdentifier(final FrontendIdentifier<T> frontendId, final long generation) {
- this.frontendId = Preconditions.checkNotNull(frontendId);
+ ClientIdentifier(final FrontendIdentifier frontendId, final long generation) {
+ this.frontendId = requireNonNull(frontendId);
this.generation = generation;
}
- public static <T extends FrontendType> ClientIdentifier<T> create(final FrontendIdentifier<T> frontendId,
+ public static @NonNull ClientIdentifier create(final FrontendIdentifier frontendId,
final long generation) {
- return new ClientIdentifier<>(frontendId, generation);
+ return new ClientIdentifier(frontendId, generation);
}
- public FrontendIdentifier<T> getFrontendId() {
+ public static @NonNull ClientIdentifier readFrom(final DataInput in) throws IOException {
+ final FrontendIdentifier frontendId = FrontendIdentifier.readFrom(in);
+ return new ClientIdentifier(frontendId, WritableObjects.readLong(in));
+ }
+
+ @Override
+ public void writeTo(final DataOutput out) throws IOException {
+ frontendId.writeTo(out);
+ WritableObjects.writeLong(out, generation);
+ }
+
+ public @NonNull FrontendIdentifier getFrontendId() {
return frontendId;
}
return generation;
}
+ public @NonNull ClientGeneration getYangGeneration() {
+ return new ClientGeneration(Uint64.fromLongBits(generation));
+ }
+
@Override
public int hashCode() {
return frontendId.hashCode() * 31 + Long.hashCode(generation);
}
@Override
- public boolean equals(final Object o) {
- if (this == o) {
- return true;
- }
- if (!(o instanceof ClientIdentifier)) {
- return false;
- }
-
- final ClientIdentifier<?> other = (ClientIdentifier<?>) o;
- return generation == other.generation && frontendId.equals(other.frontendId);
+ public boolean equals(final Object obj) {
+ return this == obj || obj instanceof ClientIdentifier other && generation == other.generation
+ && frontendId.equals(other.frontendId);
}
@Override
public String toString() {
- return MoreObjects.toStringHelper(ClientIdentifier.class).add("frontend", frontendId)
- .add("generation", Long.toUnsignedString(generation)).toString();
+ return MoreObjects.toStringHelper(ClientIdentifier.class)
+ .add("frontend", frontendId)
+ .add("generation", Long.toUnsignedString(generation))
+ .toString();
}
+ @Serial
private Object writeReplace() {
- return new Proxy<>(frontendId, generation);
+ return new Proxy(frontendId, generation);
}
}