Adapted after integrating in actual "test" bot.

Author: Bytekeeper

src/main/java/org/bk/ass/manage/SetReservation.java renamed to src/main/java/org/bk/ass/manage/BlacklistReservation.java

@@ -8,22 +8,25 @@
  *
  * @param <T>
  */
-public class SetReservation<T> implements Reservation<T> {
+public class BlacklistReservation<T> implements Reservation<T> {
 
   private final Set<T> reservedItems = new HashSet<>();
 
-  public void setReservedItems(Set<T> reservedItems) {
+  public void reset() {
     this.reservedItems.clear();
-    this.reservedItems.addAll(reservedItems);
   }
 
   @Override
-  public boolean reserve(Lock<T> lock, T item) {
+  public boolean reserve(Object source, T item) {
     return reservedItems.add(item);
   }
 
   @Override
-  public void release(Lock<T> lock, T item) {
+  public void release(Object source, T item) {
     reservedItems.remove(item);
   }
+
+  public boolean isAvailable(T item) {
+    return !reservedItems.contains(item);
+  }
 }

src/main/java/org/bk/ass/manage/GMSReservation.java

@@ -30,20 +30,20 @@ public GMS getGms() {
   }
 
   @Override
-  public boolean reserve(Lock<GMS> lock, GMS gmsToReserve) {
+  public boolean reserve(Object source, GMS gmsToReserve) {
     boolean success = gms.canAfford(gmsToReserve);
     gms = gms.subtract(gmsToReserve);
     return success;
   }
 
   @Override
-  public boolean itemAvailableInFuture(Lock<GMS> lock, GMS futureItem, int futureFrames) {
+  public boolean itemAvailableInFuture(Object source, GMS futureItem, int futureFrames) {
     GMS futureGMS = gmsPrediction.apply(futureFrames).add(gms);
     return futureGMS.canAfford(futureItem);
   }
 
   @Override
-  public void release(Lock<GMS> lock, GMS gmsToRelease) {
+  public void release(Object source, GMS gmsToRelease) {
     gms = gms.add(gmsToRelease);
   }
 }

src/main/java/org/bk/ass/manage/ListLock.java

@@ -15,13 +15,13 @@ public ListLock(Reservation<List<T>> reservation, Supplier<List<T>> selector) {
   }
 
   public boolean releaseItem(T item) {
-    return releaseItem(Collections.singletonList(item));
+    return releasePartially(Collections.singletonList(item));
   }
 
   /**
    * Releases only some of the items in the list.
    */
-  public boolean releaseItem(List<T> partial) {
+  public boolean releasePartially(List<T> partial) {
     int items = item.size();
     item.removeAll(partial);
     if (item.size() + partial.size() != items)

src/main/java/org/bk/ass/manage/ListReservation.java

@@ -0,0 +1,36 @@
+package org.bk.ass.manage;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Wrapper for {@link Reservation} to allow for "atomic" list of item reservations.
+ */
+public class ListReservation<T> implements Reservation<List<T>> {
+
+  private final Reservation<T> delegate;
+
+  public ListReservation(Reservation<T> delegate) {
+    this.delegate = delegate;
+  }
+
+  @Override
+  public boolean reserve(Object source, List<T> itemList) {
+    ArrayList<T> reservedItems = new ArrayList<>();
+    for (T item : itemList) {
+      boolean reserved = delegate.reserve(source, item);
+      if (!reserved) {
+        reservedItems.forEach(it -> delegate.release(source, it));
+        return false;
+      }
+      reservedItems.add(item);
+    }
+    return true;
+  }
+
+  @Override
+  public void release(Object source, List<T> itemList) {
+    itemList.forEach(it -> delegate.release(source, it));
+  }
+}
+

src/main/java/org/bk/ass/manage/Reservation.java

@@ -12,19 +12,19 @@ public interface Reservation<T> {
    * reserved but is not yet available. (Ie. resources might be "blocked" for later use, but not yet
    * spendable.)
    */
-  boolean reserve(Lock<T> lock, T item);
+  boolean reserve(Object source, T item);
 
   /**
    * Returns true if the given item will be available in futureFrames frames. The given item will
    * already be reserved when this is called! If used for {@link GMS}, you should re-add the given
    * {@link GMS} before checking for sufficient resources.
    */
-  default boolean itemAvailableInFuture(Lock<T> lock, T item, int futureFrames) {
+  default boolean itemAvailableInFuture(Object source, T item, int futureFrames) {
     return false;
   }
 
   /**
    * Releases the given item.
    */
-  void release(Lock<T> lock, T item);
+  void release(Object source, T item);
 }

src/main/java/org/bk/ass/manage/WhiteListReservation.java

@@ -0,0 +1,22 @@
+package org.bk.ass.manage;
+
+import java.util.Collection;
+
+public class WhiteListReservation<T, S extends Collection<T>> implements Reservation<T> {
+
+  public S availableItems;
+
+  public boolean isAvailable(T item) {
+    return availableItems.contains(item);
+  }
+
+  @Override
+  public boolean reserve(Object source, T item) {
+    return availableItems.remove(item);
+  }
+
+  @Override
+  public void release(Object source, T item) {
+    availableItems.add(item);
+  }
+}