[ci skip]refactor: convert AbstractConcurrentTable to interface and update ConcurrentTable implementation

gradle.properties

@@ -9,7 +9,7 @@ release=true
 # true for push to repo, false for skip push repo, auto for detect by release value
 pushRepo=auto
 
-luminolRef=4a1d048cd05452cd3e2512018996e4d5bb74ce82
+luminolRef=681db5ba70f72fc1cbfbf5ece5f411bdd8110057
 
 org.gradle.configuration-cache=true
 org.gradle.caching=true

lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/AbstractConcurrentTable.java

@@ -3,34 +3,34 @@ package fun.bm.lophine.utils.concurrent;
 import java.util.List;
 import java.util.Map;
 
-public abstract class AbstractConcurrentTable<X, Y, Z> {
-    public abstract void put(X x, Y y, Z z);
+public interface AbstractConcurrentTable<X, Y, Z> {
+    void put(X x, Y y, Z z);
 
-    public abstract void remove(X x, Y y, Z z);
+    void remove(X x, Y y, Z z);
 
-    public abstract List<Z> getZ(X x, Y y);
+    List<Z> getZ(X x, Y y);
 
-    public abstract List<Y> getY(X x, Z z);
+    List<Y> getY(X x, Z z);
 
-    public abstract List<X> getX(Y y, Z z);
+    List<X> getX(Y y, Z z);
 
-    public abstract Map<X, Y> getXY(Z z);
+    Map<X, Y> getXY(Z z);
 
-    public abstract Map<Y, Z> getYZ(X x);
+    Map<Y, Z> getYZ(X x);
 
-    public abstract Map<X, Z> getXZ(Y y);
+    Map<X, Z> getXZ(Y y);
 
-    public abstract List<X> getAllX();
+    List<X> getAllX();
 
-    public abstract List<Y> getAllY();
+    List<Y> getAllY();
 
-    public abstract List<Z> getAllZ();
+    List<Z> getAllZ();
 
-    public abstract void clearXY(Z z);
+    void clearXY(Z z);
 
-    public abstract void clearYZ(X x);
+    void clearYZ(X x);
 
-    public abstract void clearXZ(Y y);
+    void clearXZ(Y y);
 
-    public abstract void clearAll();
+    void clearAll();
 }

lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/ConcurrentTable.java

@@ -7,7 +7,7 @@ import java.util.Map;
 import java.util.concurrent.ConcurrentLinkedDeque;
 import java.util.function.Predicate;
 
-public class ConcurrentTable<X, Y, Z> extends AbstractConcurrentTable<X, Y, Z> {
+public class ConcurrentTable<X, Y, Z> implements AbstractConcurrentTable<X, Y, Z> {
     protected final ConcurrentLinkedDeque<TableEntry<X, Y, Z>> data = new ConcurrentLinkedDeque<>();
     protected final boolean flagX;
     protected final boolean flagY;
@@ -60,88 +60,88 @@ public class ConcurrentTable<X, Y, Z> extends AbstractConcurrentTable<X, Y, Z> {
 
     @Override
     public void remove(X x, Y y, Z z) {
-        data.removeIf(entry -> entry.getX().equals(x) && entry.getY().equals(y) && entry.getZ().equals(z));
+        data.removeIf(entry -> entry.x().equals(x) && entry.y().equals(y) && entry.z().equals(z));
     }
 
     @Override
     public List<Z> getZ(X x, Y y) {
         return filterAndCollect(
-                entry -> entry.getX().equals(x) && entry.getY().equals(y),
-                TableEntry::getZ
+                entry -> entry.x().equals(x) && entry.y().equals(y),
+                TableEntry::z
         );
     }
 
     @Override
     public List<Y> getY(X x, Z z) {
         return filterAndCollect(
-                entry -> entry.getX().equals(x) && entry.getZ().equals(z),
-                TableEntry::getY
+                entry -> entry.x().equals(x) && entry.z().equals(z),
+                TableEntry::y
         );
     }
 
     @Override
     public List<X> getX(Y y, Z z) {
         return filterAndCollect(
-                entry -> entry.getY().equals(y) && entry.getZ().equals(z),
-                TableEntry::getX
+                entry -> entry.y().equals(y) && entry.z().equals(z),
+                TableEntry::x
         );
     }
 
     @Override
     public Map<X, Y> getXY(Z z) {
         return filterAndMap(
-                entry -> entry.getZ().equals(z),
-                TableEntry::getX,
-                TableEntry::getY
+                entry -> entry.z().equals(z),
+                TableEntry::x,
+                TableEntry::y
         );
     }
 
     @Override
     public Map<Y, Z> getYZ(X x) {
         return filterAndMap(
-                entry -> entry.getX().equals(x),
-                TableEntry::getY,
-                TableEntry::getZ
+                entry -> entry.x().equals(x),
+                TableEntry::y,
+                TableEntry::z
         );
     }
 
     @Override
     public Map<X, Z> getXZ(Y y) {
         return filterAndMap(
-                entry -> entry.getY().equals(y),
-                TableEntry::getX,
-                TableEntry::getZ
+                entry -> entry.y().equals(y),
+                TableEntry::x,
+                TableEntry::z
         );
     }
 
     @Override
     public List<X> getAllX() {
-        return collectAll(TableEntry::getX);
+        return collectAll(TableEntry::x);
     }
 
     @Override
     public List<Y> getAllY() {
-        return collectAll(TableEntry::getY);
+        return collectAll(TableEntry::y);
     }
 
     @Override
     public List<Z> getAllZ() {
-        return collectAll(TableEntry::getZ);
+        return collectAll(TableEntry::z);
     }
 
     @Override
     public void clearXY(Z z) {
-        data.removeIf(entry -> entry.getZ().equals(z));
+        data.removeIf(entry -> entry.z().equals(z));
     }
 
     @Override
     public void clearYZ(X x) {
-        data.removeIf(entry -> entry.getX().equals(x));
+        data.removeIf(entry -> entry.x().equals(x));
     }
 
     @Override
     public void clearXZ(Y y) {
-        data.removeIf(entry -> entry.getY().equals(y));
+        data.removeIf(entry -> entry.y().equals(y));
     }
 
     @Override

lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/OptimizedConcurrentTable.java

@@ -76,9 +76,9 @@ public class OptimizedConcurrentTable<X, Y, Z> extends ConcurrentTable<X, Y, Z>
         data.removeIf(entry -> {
             boolean shouldRemove = predicate.test(entry);
             if (shouldRemove) {
-                removeFromIndex(xyIndex, entry.getX(), entry.getY(), entry.getZ());
-                removeFromIndex(yzIndex, entry.getY(), entry.getZ(), entry.getX());
-                removeFromIndex(zxIndex, entry.getZ(), entry.getX(), entry.getY());
+                removeFromIndex(xyIndex, entry.x(), entry.y(), entry.z());
+                removeFromIndex(yzIndex, entry.y(), entry.z(), entry.x());
+                removeFromIndex(zxIndex, entry.z(), entry.x(), entry.y());
             }
             return shouldRemove;
         });
@@ -86,9 +86,9 @@ public class OptimizedConcurrentTable<X, Y, Z> extends ConcurrentTable<X, Y, Z>
 
     public boolean putIfAbsent(X x, Y y, Z z) {
         if (data.stream().anyMatch(entry ->
-                Objects.equals(entry.getX(), x) &&
-                        Objects.equals(entry.getY(), y) &&
-                        Objects.equals(entry.getZ(), z))) {
+                Objects.equals(entry.x(), x) &&
+                        Objects.equals(entry.y(), y) &&
+                        Objects.equals(entry.z(), z))) {
             return false;
         }
         put(x, y, z);

lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/TableEntry.java

@@ -1,25 +1,4 @@
 package fun.bm.lophine.utils.concurrent;
 
-public class TableEntry<X, Y, Z> {
-    private final X x;
-    private final Y y;
-    private final Z z;
-
-    public TableEntry(X x, Y y, Z z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-
-    public X getX() {
-        return x;
-    }
-
-    public Y getY() {
-        return y;
-    }
-
-    public Z getZ() {
-        return z;
-    }
+public record TableEntry<X, Y, Z>(X x, Y y, Z z) {
 }