Add scheduled executor to enforce deadlines, make packager closable

api/src/main/java/com/github/skjolber/packing/api/Packager.java

@@ -1,12 +1,14 @@
 package com.github.skjolber.packing.api;
 
+import java.io.Closeable;
+
 /**
  * Fit boxes into container, i.e. perform bin packing to a single container.
  *
  * Thread-safe implementation.
  */
 
-public interface Packager<B extends PackagerResultBuilder<B>> {
+public interface Packager<B extends PackagerResultBuilder<B>> extends Closeable {
 
 	B newResultBuilder();
 

core/src/main/java/com/github/skjolber/packing/deadline/DeadlineCheckPackagerInterruptSupplier.java

@@ -1,17 +1,34 @@
 package com.github.skjolber.packing.deadline;
 
-public class DeadlineCheckPackagerInterruptSupplier implements PackagerInterruptSupplier {
+import java.io.Closeable;
+import java.util.concurrent.ScheduledFuture;
 
-	protected final long deadline;
+public class DeadlineCheckPackagerInterruptSupplier implements PackagerInterruptSupplier, Runnable, Closeable {
 
-	public DeadlineCheckPackagerInterruptSupplier(long deadline) {
-		super();
-		this.deadline = deadline;
+	// this is not entirely accurate for multi-threading, but close enough
+	// (should have been volatile)
+	protected boolean expired = false;
+	protected ScheduledFuture<?> future;
+
+	public DeadlineCheckPackagerInterruptSupplier() {
 	}
 
 	@Override
 	public boolean getAsBoolean() {
-		return System.currentTimeMillis() > deadline;
+		return expired;
+	}
+
+	@Override
+	public void run() {
+		this.expired = true;
+	}
+
+	public void close() {
+		future.cancel(true);
+	}
+
+	public void setFuture(ScheduledFuture<?> future) {
+		this.future = future;
 	}
 
 }

core/src/main/java/com/github/skjolber/packing/deadline/DelegateDeadlineCheckPackagerInterruptSupplier.java

@@ -1,21 +1,38 @@
 package com.github.skjolber.packing.deadline;
 
+import java.io.Closeable;
+import java.util.concurrent.ScheduledFuture;
 import java.util.function.BooleanSupplier;
 
-public class DelegateDeadlineCheckPackagerInterruptSupplier implements PackagerInterruptSupplier {
+public class DelegateDeadlineCheckPackagerInterruptSupplier implements PackagerInterruptSupplier, Runnable, Closeable {
 
+	// this is not entirely accurate for multi-threading, but close enough
+	// (should have been volatile)
+	protected boolean expired = false;
+	protected ScheduledFuture<?> future;
 	protected final BooleanSupplier delegate;
-	protected final long deadline;
-
-	public DelegateDeadlineCheckPackagerInterruptSupplier(long deadline, BooleanSupplier delegate) {
+
+	public DelegateDeadlineCheckPackagerInterruptSupplier(BooleanSupplier delegate) {
 		super();
-		this.deadline = deadline;
 		this.delegate = delegate;
 	}
 
 	@Override
 	public boolean getAsBoolean() {
-		return delegate.getAsBoolean() || System.currentTimeMillis() > deadline;
+		return expired || delegate.getAsBoolean();
+	}
+
+	@Override
+	public void run() {
+		this.expired = true;
+	}
+
+	public void close() {
+		future.cancel(true);
+	}
+
+	public void setFuture(ScheduledFuture<?> future) {
+		this.future = future;
 	}
 
 }

core/src/main/java/com/github/skjolber/packing/deadline/PackagerInterruptSupplier.java

@@ -1,12 +1,17 @@
 package com.github.skjolber.packing.deadline;
 
+import java.io.Closeable;
+
 @FunctionalInterface
-public interface PackagerInterruptSupplier {
+public interface PackagerInterruptSupplier extends Closeable {
 
 	/**
 	 * Gets a result.
 	 *
 	 * @return a result
 	 */
 	boolean getAsBoolean();
+
+	default void close() {
+	}
 }

core/src/main/java/com/github/skjolber/packing/deadline/PackagerInterruptSupplierBuilder.java

@@ -1,49 +1,61 @@
 package com.github.skjolber.packing.deadline;
 
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 import java.util.function.BooleanSupplier;
 
 public class PackagerInterruptSupplierBuilder {
 
 	public static final NegativePackagerInterruptSupplier NOOP = new NegativePackagerInterruptSupplier();
 
 	private long deadline = Long.MAX_VALUE;
-	private int checkpointsPerDeadlineCheck = 1;
 	private BooleanSupplier interrupt = null;
+	private ScheduledThreadPoolExecutor scheduledThreadPoolExecutor;
 
 	public static PackagerInterruptSupplierBuilder builder() {
 		return new PackagerInterruptSupplierBuilder();
 	}
 
-	public PackagerInterruptSupplierBuilder withDeadline(long deadline, int checkpointsPerDeadlineCheck) {
+	public PackagerInterruptSupplierBuilder withDeadline(long deadline) {
 		this.deadline = deadline;
-		this.checkpointsPerDeadlineCheck = checkpointsPerDeadlineCheck;
 		return this;
 	}
 
 	public PackagerInterruptSupplierBuilder withInterrupt(BooleanSupplier interrupt) {
 		this.interrupt = interrupt;
 		return this;
 	}
+
+	public PackagerInterruptSupplierBuilder withScheduledThreadPoolExecutor(ScheduledThreadPoolExecutor executor) {
+		this.scheduledThreadPoolExecutor = executor;
+		return this;
+	}
 
 	public PackagerInterruptSupplier build() {
-		if(checkpointsPerDeadlineCheck == Integer.MAX_VALUE || checkpointsPerDeadlineCheck == -1 || deadline == Long.MAX_VALUE || deadline == -1L) {
+		if(deadline == Long.MAX_VALUE || deadline == -1L) {
 			// no deadline
 			if(interrupt != null) {
 				return new DefaultPackagerInterrupt(interrupt);
 			}
 			return NOOP;
 		}
-
-		if(checkpointsPerDeadlineCheck == 1) {
-			if(interrupt == null) {
-				return new DeadlineCheckPackagerInterruptSupplier(deadline);
-			}
-			return new DelegateDeadlineCheckPackagerInterruptSupplier(deadline, interrupt);
+
+		if(scheduledThreadPoolExecutor == null) {
+			throw new IllegalStateException("Expected scheduler");
 		}
+
 		if(interrupt == null) {
-			return new NthDeadlineCheckPackagerInterruptSupplier(deadline, checkpointsPerDeadlineCheck);
+			DeadlineCheckPackagerInterruptSupplier supplier = new DeadlineCheckPackagerInterruptSupplier();
+			ScheduledFuture<?> schedule = scheduledThreadPoolExecutor.schedule(supplier, deadline - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
+			supplier.setFuture(schedule);
+			return supplier;
 		}
-		return new DelegateNthDeadlineCheckPackagerInterruptSupplier(deadline, checkpointsPerDeadlineCheck, interrupt);
+
+		DelegateDeadlineCheckPackagerInterruptSupplier supplier = new DelegateDeadlineCheckPackagerInterruptSupplier(interrupt);
+		ScheduledFuture<?> schedule = scheduledThreadPoolExecutor.schedule(supplier, deadline - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
+		supplier.setFuture(schedule);
+		return supplier;
 	}
 
 }

core/src/main/java/com/github/skjolber/packing/iterator/PermutationRotationIterator.java

@@ -40,7 +40,7 @@ public interface PermutationRotationIterator {
 	/**
 	 * Get current permutations
 	 * 
-	 * @return
+	 * @return current permutations array
 	 */
 
 	int[] getPermutations();
@@ -49,7 +49,7 @@ public interface PermutationRotationIterator {
 	 * 
 	 * Get current length
 	 * 
-	 * @return
+	 * @return current length of permutations array
 	 */
 
 	int length();
@@ -112,7 +112,7 @@ public interface PermutationRotationIterator {
 	 * 
 	 * @param state  previously saved state
 	 * @param length number of items
-	 * @return
+	 * @return current permutations + rotations
 	 */
 
 	List<PermutationRotation> get(PermutationRotationState state, int length);

core/src/main/java/com/github/skjolber/packing/packer/AbstractPackager.java

@@ -3,6 +3,7 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
 
 import com.github.skjolber.packing.api.Container;
 import com.github.skjolber.packing.api.ContainerItem;
@@ -27,18 +28,16 @@ public abstract class AbstractPackager<P extends PackResult, B extends PackagerR
 	protected static final EmptyPackResult EMPTY_PACK_RESULT = EmptyPackResult.EMPTY;
 
 	protected final PackResultComparator packResultComparator;
-
-	/** limit the number of calls to get System.currentTimeMillis() */
-	protected final int checkpointsPerDeadlineCheck;
+
+	protected final ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(Integer.MAX_VALUE);
 
 	/**
 	 * Constructor
 	 *
-	 * @param checkpointsPerDeadlineCheck number of deadline checks to skip, before checking again
+	 * @param packResultComparator result comparator
 	 */
 
-	public AbstractPackager(int checkpointsPerDeadlineCheck, PackResultComparator packResultComparator) {
-		this.checkpointsPerDeadlineCheck = checkpointsPerDeadlineCheck;
+	public AbstractPackager(PackResultComparator packResultComparator) {
 		this.packResultComparator = packResultComparator;
 	}
 
@@ -143,6 +142,7 @@ public List<Container> packList(List<StackableItem> products, List<ContainerItem
 	 * Return a list of containers which holds all the boxes in the argument
 	 *
 	 * @param boxes     list of boxes to fit in a container
+	 * @param containerItems list of containers available for use in this operation
 	 * @param limit     maximum number of containers
 	 * @param interrupt When true, the computation is interrupted as soon as possible.
 	 * @return list of containers, or null if the deadline was reached, or empty list if the packages could not be packaged within the available containers and/or limit.
@@ -283,5 +283,9 @@ protected long getMinStackableArea(List<Stackable> stackables) {
 		}
 		return minArea;
 	}
-
+
+	public void close() {
+		scheduledThreadPoolExecutor.shutdownNow();
+	}
+
 }

core/src/main/java/com/github/skjolber/packing/packer/AbstractPackagerBuilder.java

@@ -11,7 +11,6 @@
 @SuppressWarnings({ "rawtypes", "unchecked" })
 public abstract class AbstractPackagerBuilder<P extends Packager, B extends AbstractPackagerBuilder<P, B>> {
 
-	protected int checkpointsPerDeadlineCheck = 1;
 	protected PackResultComparator packResultComparator;
 
 	public B withPackResultComparator(PackResultComparator packResultComparator) {
@@ -20,11 +19,6 @@ public B withPackResultComparator(PackResultComparator packResultComparator) {
 		return (B)this;
 	}
 
-	public B withCheckpointsPerDeadlineCheck(int n) {
-		this.checkpointsPerDeadlineCheck = n;
-		return (B)this;
-	}
-
 	public abstract P build();
 
 }