nachonekoawa/Lophine
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Helvetica Volubi
2026-06-13 01:19:56 +08:00
parent 3763d0b885
commit 0989bcaec7
5 changed files with 47 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/AbstractConcurrentTable.java
+16 -16
View File
@@ -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
+23 -23
View File
@@ -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
+6 -6
View File
@@ -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 -22
View File
@@ -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) {
}