Random quest ID

src/main/java/betterquesting/api2/storage/AbstractDatabase.java

@@ -0,0 +1,127 @@
+package betterquesting.api2.storage;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.TreeMap;
+
+public abstract class AbstractDatabase<T> implements IDatabase<T> {
+
+    /**
+     * If the cache size would somehow exceed 24MB (on 64bit machines) we stop.
+     */
+    public static int CACHE_MAX_SIZE = 24 * 1024 * 1024 / 8;
+
+    /**
+     * If {@code mapDB.size < SPARSE_RATIO * (mapDB.lastKey() - mapDB.firstKey())} the database will be considered
+     * sparse and an cache array won't be built to save memory.
+     * <p>
+     * Under this sparsity a 10k element database will roughly result in a 0.5MB cache which is more than enough reasonable.
+     */
+    public static double SPARSE_RATIO = 0.15d;
+
+    final TreeMap<Integer, T> mapDB = new TreeMap<>();
+
+    private LookupLogicType type = null;
+    private LookupLogic<T> logic = null;
+
+    private LookupLogic<T> getLookupLogic() {
+        if (type != null)
+            return logic;
+        LookupLogicType newType = LookupLogicType.determine(this);
+        type = newType;
+        logic = newType.get(this);
+        return logic;
+    }
+
+    private void updateLookupLogic() {
+        if (type == null)
+            return;
+        LookupLogicType newType = LookupLogicType.determine(this);
+        if (newType != type) {
+            type = null;
+            logic = null;
+        } else {
+            logic.onDataChange();
+        }
+    }
+
+    @Override
+    public synchronized DBEntry<T> add(int id, T value) {
+        if (value == null) {
+            throw new NullPointerException("Value cannot be null");
+        } else if (id < 0) {
+            throw new IllegalArgumentException("ID cannot be negative");
+        } else {
+            if (mapDB.putIfAbsent(id, value) == null) {
+                updateLookupLogic();
+                return new DBEntry<>(id, value);
+            } else {
+                throw new IllegalArgumentException("ID or value is already contained within database");
+            }
+        }
+    }
+
+    @Override
+    public synchronized boolean removeID(int key) {
+        if (key < 0)
+            return false;
+
+        if (mapDB.remove(key) != null) {
+            updateLookupLogic();
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public synchronized boolean removeValue(T value) {
+        return value != null && removeID(getID(value));
+    }
+
+    @Override
+    public synchronized int getID(T value) {
+        if (value == null)
+            return -1;
+
+        for (DBEntry<T> entry : getEntries()) {
+            if (entry.getValue() == value)
+                return entry.getID();
+        }
+
+        return -1;
+    }
+
+    @Override
+    public synchronized T getValue(int id) {
+        if (id < 0 || mapDB.size() <= 0)
+            return null;
+        return mapDB.get(id);
+    }
+
+    @Override
+    public synchronized int size() {
+        return mapDB.size();
+    }
+
+    @Override
+    public synchronized void reset() {
+        mapDB.clear();
+        type = null;
+        logic = null;
+    }
+
+    @Override
+    public synchronized List<DBEntry<T>> getEntries() {
+        return mapDB.isEmpty() ? Collections.emptyList() : getLookupLogic().getRefCache();
+    }
+
+    /**
+     * First try to use array cache.
+     * If memory usage would be too high try use sort merge join if keys is large.
+     * Otherwise look up each key separately via {@link TreeMap#get(Object)}.
+     */
+    @Override
+    public synchronized List<DBEntry<T>> bulkLookup(int... keys) {
+        return mapDB.isEmpty() || keys.length == 0 ? Collections.emptyList() : getLookupLogic().bulkLookup(keys);
+    }
+}

src/main/java/betterquesting/api2/storage/ArrayCacheLookupLogic.java

@@ -8,8 +8,8 @@ class ArrayCacheLookupLogic<T> extends LookupLogic<T> {
     private DBEntry<T>[] cache = null;
     private int offset = -1;
 
-    public ArrayCacheLookupLogic(SimpleDatabase<T> simpleDatabase) {
-        super(simpleDatabase);
+    public ArrayCacheLookupLogic(AbstractDatabase<T> abstractDatabase) {
+        super(abstractDatabase);
     }
 
     @Override
@@ -21,7 +21,8 @@ public void onDataChange() {
 
     @Override
     public List<DBEntry<T>> getRefCache() {
-        if (refCache != null) return refCache;
+        if (refCache != null)
+            return refCache;
         if (cache == null) {
             return super.getRefCache();
         } else {
@@ -35,7 +36,8 @@ public List<DBEntry<T>> bulkLookup(int[] keys) {
         computeCache();
         List<DBEntry<T>> list = new ArrayList<>(keys.length);
         for (int k : keys) {
-            if (k - offset >= cache.length) continue;
+            if (k - offset >= cache.length)
+                continue;
             final DBEntry<T> element = cache[k - offset];
             if (element != null) {
                 // it shouldn't place too much allocation/gc pressure since there aren't too many keys to look up anyway
@@ -47,11 +49,12 @@ public List<DBEntry<T>> bulkLookup(int[] keys) {
 
     @SuppressWarnings("unchecked")
     private void computeCache() {
-        if (cache != null) return;
-        cache = new DBEntry[simpleDatabase.mapDB.lastKey() - simpleDatabase.mapDB.firstKey() + 1];
-        offset = simpleDatabase.mapDB.firstKey();
+        if (cache != null)
+            return;
+        cache = new DBEntry[abstractDatabase.mapDB.lastKey() - abstractDatabase.mapDB.firstKey() + 1];
+        offset = abstractDatabase.mapDB.firstKey();
         if (refCache == null) {
-            for (Map.Entry<Integer, T> entry : simpleDatabase.mapDB.entrySet()) {
+            for (Map.Entry<Integer, T> entry : abstractDatabase.mapDB.entrySet()) {
                 cache[entry.getKey() - offset] = new DBEntry<>(entry.getKey(), entry.getValue());
             }
         } else {

src/main/java/betterquesting/api2/storage/EmptyLookupLogic.java

@@ -5,8 +5,8 @@
 
 public class EmptyLookupLogic<T> extends LookupLogic<T> {
 
-    public EmptyLookupLogic(SimpleDatabase<T> simpleDatabase) {
-        super(simpleDatabase);
+    public EmptyLookupLogic(AbstractDatabase<T> abstractDatabase) {
+        super(abstractDatabase);
     }
 
     @Override

src/main/java/betterquesting/api2/storage/LookupLogic.java

@@ -7,19 +7,20 @@
 
 abstract class LookupLogic<T> {
 
-    protected final SimpleDatabase<T> simpleDatabase;
+    protected final AbstractDatabase<T> abstractDatabase;
     protected List<DBEntry<T>> refCache = null;
 
-    public LookupLogic(SimpleDatabase<T> simpleDatabase) {
-        this.simpleDatabase = simpleDatabase;
+    public LookupLogic(AbstractDatabase<T> abstractDatabase) {
+        this.abstractDatabase = abstractDatabase;
     }
 
     public void onDataChange() {
         refCache = null;
     }
 
     public List<DBEntry<T>> getRefCache() {
-        if (refCache != null) return refCache;
+        if (refCache != null)
+            return refCache;
         computeRefCache();
         return refCache;
     }
@@ -28,7 +29,7 @@ public List<DBEntry<T>> getRefCache() {
 
     protected void computeRefCache() {
         List<DBEntry<T>> temp = new ArrayList<>();
-        for (Map.Entry<Integer, T> entry : simpleDatabase.mapDB.entrySet()) {
+        for (Map.Entry<Integer, T> entry : abstractDatabase.mapDB.entrySet()) {
             temp.add(new DBEntry<>(entry.getKey(), entry.getValue()));
         }
         refCache = Collections.unmodifiableList(temp);

src/main/java/betterquesting/api2/storage/LookupLogicType.java

@@ -11,15 +11,15 @@ enum LookupLogicType {
     Empty(db -> db.mapDB.isEmpty(), EmptyLookupLogic::new),
     ArrayCache(db -> db.mapDB.size() < CACHE_MAX_SIZE && db.mapDB.size() > SPARSE_RATIO * (db.mapDB.lastKey() - db.mapDB.firstKey()), ArrayCacheLookupLogic::new),
     Naive(db -> true, NaiveLookupLogic::new);
-    private final Predicate<SimpleDatabase<?>> shouldUse;
-    private final Function<SimpleDatabase<?>, LookupLogic<?>> factory;
+    private final Predicate<AbstractDatabase<?>> shouldUse;
+    private final Function<AbstractDatabase<?>, LookupLogic<?>> factory;
 
-    LookupLogicType(Predicate<SimpleDatabase<?>> shouldUse, Function<SimpleDatabase<?>, LookupLogic<?>> factory) {
+    LookupLogicType(Predicate<AbstractDatabase<?>> shouldUse, Function<AbstractDatabase<?>, LookupLogic<?>> factory) {
         this.shouldUse = shouldUse;
         this.factory = factory;
     }
 
-    static LookupLogicType determine(SimpleDatabase<?> db) {
+    static LookupLogicType determine(AbstractDatabase<?> db) {
         for (LookupLogicType type : values()) {
             if (type.shouldUse.test(db))
                 return type;
@@ -28,7 +28,7 @@ static LookupLogicType determine(SimpleDatabase<?> db) {
     }
 
     @SuppressWarnings("unchecked")
-    <T> LookupLogic<T> get(SimpleDatabase<T> db) {
+    <T> LookupLogic<T> get(AbstractDatabase<T> db) {
         return (LookupLogic<T>) factory.apply(db);
     }
 }

src/main/java/betterquesting/api2/storage/NaiveLookupLogic.java

@@ -10,8 +10,8 @@ class NaiveLookupLogic<T> extends LookupLogic<T> {
 
     private TIntObjectMap<DBEntry<T>> backingMap;
 
-    public NaiveLookupLogic(SimpleDatabase<T> simpleDatabase) {
-        super(simpleDatabase);
+    public NaiveLookupLogic(AbstractDatabase<T> abstractDatabase) {
+        super(abstractDatabase);
     }
 
     @Override
@@ -23,7 +23,7 @@ public void onDataChange() {
     @Override
     public List<DBEntry<T>> bulkLookup(int[] keys) {
         if (backingMap == null) {
-            backingMap = new TIntObjectHashMap<>(simpleDatabase.mapDB.size());
+            backingMap = new TIntObjectHashMap<>(abstractDatabase.mapDB.size());
             for (DBEntry<T> entry : getRefCache()) {
                 backingMap.put(entry.getID(), entry);
             }

src/main/java/betterquesting/api2/storage/RandomIndexDatabase.java

@@ -0,0 +1,22 @@
+package betterquesting.api2.storage;
+
+import java.util.Random;
+
+public class RandomIndexDatabase<T> extends AbstractDatabase<T> {
+
+    private final Random random = new Random();
+
+    @Override
+    public synchronized int nextID() {
+        int id;
+        do {
+            // id >= 0
+            id = random.nextInt() & 0x7fff_ffff;
+        }
+        // The new id doesn't conflict with existing ones.
+        // However, new ids created by different players could conflict with each other.
+        while (mapDB.containsKey(id));
+        return id;
+    }
+
+}