opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/persisted/SimpleReplicatedLogEntry.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.controller.cluster.raft.persisted;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import java.io.Externalizable;
  13 import java.io.IOException;
  14 import java.io.ObjectInput;
  15 import java.io.ObjectOutput;
  16 import java.io.Serializable;
  17 import org.apache.commons.lang3.SerializationUtils;
  18 import org.opendaylight.controller.cluster.raft.ReplicatedLogEntry;
  19 import org.opendaylight.controller.cluster.raft.messages.Payload;
  20
  21 /**
  22  * A {@link ReplicatedLogEntry} implementation.
  23  *
  24  * @author Thomas Pantelis
  25  */
  26 public sealed class SimpleReplicatedLogEntry implements ReplicatedLogEntry, Serializable {
  27     @Deprecated(since = "7.0.0", forRemoval = true)
  28     private static final class Legacy extends SimpleReplicatedLogEntry implements LegacySerializable {
  29         @java.io.Serial
  30         private static final long serialVersionUID = 1L;
  31
  32         Legacy(final long index, final long term, final Payload payload) {
  33             super(index, term, payload);
  34         }
  35     }
  36
  37     @Deprecated(since = "7.0.0", forRemoval = true)
  38     private static final class Proxy implements Externalizable {
  39         @java.io.Serial
  40         private static final long serialVersionUID = 1L;
  41
  42         private long index;
  43         private long term;
  44         private Payload data;
  45
  46         // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
  47         // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
  48         @SuppressWarnings("checkstyle:RedundantModifier")
  49         public Proxy() {
  50             // For Externalizable
  51         }
  52
  53         @Override
  54         public void writeExternal(final ObjectOutput out) throws IOException {
  55             out.writeLong(index);
  56             out.writeLong(term);
  57             out.writeObject(data);
  58         }
  59
  60         @Override
  61         public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
  62             index = in.readLong();
  63             term = in.readLong();
  64             data = (Payload) in.readObject();
  65         }
  66
  67         @java.io.Serial
  68         private Object readResolve() {
  69             return new Legacy(index, term, data);
  70         }
  71     }
  72
  73     @java.io.Serial
  74     private static final long serialVersionUID = 1L;
  75     // Estimate to how big the proxy is. Note this includes object stream overhead, so it is a bit conservative.
  76     private static final int PROXY_SIZE = SerializationUtils.serialize(new LE((Void) null)).length;
  77
  78     private final long index;
  79     private final long term;
  80     private final Payload payload;
  81     private boolean persistencePending;
  82
  83     /**
  84      * Constructs an instance.
  85      *
  86      * @param index the index
  87      * @param term the term
  88      * @param payload the payload
  89      */
  90     public SimpleReplicatedLogEntry(final long index, final long term, final Payload payload) {
  91         this.index = index;
  92         this.term = term;
  93         this.payload = requireNonNull(payload);
  94     }
  95
  96     @Override
  97     public final Payload getData() {
  98         return payload;
  99     }
 100
 101     @Override
 102     public final long getTerm() {
 103         return term;
 104     }
 105
 106     @Override
 107     public final long getIndex() {
 108         return index;
 109     }
 110
 111     @Override
 112     public final int size() {
 113         return payload.size();
 114     }
 115
 116     @Override
 117     public final int serializedSize() {
 118         return PROXY_SIZE + payload.serializedSize();
 119     }
 120
 121     @Override
 122     public final boolean isPersistencePending() {
 123         return persistencePending;
 124     }
 125
 126     @Override
 127     public final void setPersistencePending(final boolean pending) {
 128         persistencePending = pending;
 129     }
 130
 131     @java.io.Serial
 132     public final Object writeReplace() {
 133         return new LE(this);
 134     }
 135
 136     @Override
 137     public final int hashCode() {
 138         final int prime = 31;
 139         int result = 1;
 140         result = prime * result + payload.hashCode();
 141         result = prime * result + (int) (index ^ index >>> 32);
 142         result = prime * result + (int) (term ^ term >>> 32);
 143         return result;
 144     }
 145
 146     @Override
 147     public final boolean equals(final Object obj) {
 148         return this == obj || obj instanceof SimpleReplicatedLogEntry other && index == other.index
 149             && term == other.term && payload.equals(other.payload);
 150     }
 151
 152     @Override
 153     public final String toString() {
 154         return "SimpleReplicatedLogEntry [index=" + index + ", term=" + term + ", payload=" + payload + "]";
 155     }
 156 }