Add scheduled executor to enforce deadlines, make packager closable (#907)

* Add scheduled executor to enforce deadlines, make packager closable

* Add fool-proofed duration check

Author: skjolber

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/DelegateNthDeadlineCheckPackagerInterruptSupplier.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/NthDeadlineCheckPackagerInterruptSupplier.java

@@ -1,49 +1,68 @@
 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();
+	public static final NegativePackagerInterruptSupplier NEGATIVE = new NegativePackagerInterruptSupplier();
+	public static final PositivePackagerInterruptSupplier POSITIVE = new PositivePackagerInterruptSupplier();
 
 	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;
+			return NEGATIVE;
 		}
 
-		if(checkpointsPerDeadlineCheck == 1) {
-			if(interrupt == null) {
-				return new DeadlineCheckPackagerInterruptSupplier(deadline);
-			}
-			return new DelegateDeadlineCheckPackagerInterruptSupplier(deadline, interrupt);
+		long delay = deadline - System.currentTimeMillis();
+		if(delay <= 0) {
+			return POSITIVE; // i.e. time is already up
+		}
+
+		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, delay, TimeUnit.MILLISECONDS);
+			supplier.setFuture(schedule);
+			return supplier;
 		}
-		return new DelegateNthDeadlineCheckPackagerInterruptSupplier(deadline, checkpointsPerDeadlineCheck, interrupt);
+		
+		DelegateDeadlineCheckPackagerInterruptSupplier supplier = new DelegateDeadlineCheckPackagerInterruptSupplier(interrupt);
+		ScheduledFuture<?> schedule = scheduledThreadPoolExecutor.schedule(supplier, delay, TimeUnit.MILLISECONDS);
+		supplier.setFuture(schedule);
+		return supplier;
 	}
 
 }

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

@@ -0,0 +1,10 @@
+package com.github.skjolber.packing.deadline;
+
+public class PositivePackagerInterruptSupplier implements PackagerInterruptSupplier {
+
+	@Override
+	public boolean getAsBoolean() {
+		return true;
+	}
+
+}

core/src/main/java/com/github/skjolber/packing/deadline/PackagerInterruptSupplier.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);