content: /*
   * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   */
  
  /*
   *
   *
   *
   *
   *
   * Written by Doug Lea with assistance from members of JCP JSR-166
   * Expert Group and released to the public domain, as explained at
   * http://creativecommons.org/publicdomain/zero/1.0/
   */
  
  package io.akarin.api.internal.utils.thread;
  
  import java.util.concurrent.BlockingQueue;
  import java.util.concurrent.Callable;
  import java.util.concurrent.CompletionService;
  import java.util.concurrent.Future;
  import java.util.concurrent.FutureTask;
  import java.util.concurrent.LinkedBlockingQueue;
  import java.util.concurrent.RunnableFuture;
  import java.util.concurrent.TimeUnit;
  
  public class SuspendableExecutorCompletionService<V> implements CompletionService<V> {
      private final SuspendableThreadPoolExecutor executor;
      private final BlockingQueue<Future<V>> completionQueue;
      
      public void suspend() {
          executor.suspend();
      }
      
      public void resume() {
          executor.resume();
      }
  
      /**
       * FutureTask extension to enqueue upon completion
       */
      private class QueueingFuture extends FutureTask<Void> {
          QueueingFuture(RunnableFuture<V> task) {
              super(task, null);
              this.task = task;
          }
          protected void done() { completionQueue.add(task); }
          private final Future<V> task;
      }
  
      private RunnableFuture<V> newTaskFor(Callable<V> task) {
          return new FutureTask<V>(task);
      }
  
      private RunnableFuture<V> newTaskFor(Runnable task, V result) {
          return new FutureTask<V>(task, result);
      }
  
      /**
       * Creates an ExecutorCompletionService using the supplied
       * executor for base task execution and a
       * {@link LinkedBlockingQueue} as a completion queue.
       *
       * @param executor the executor to use
       * @throws NullPointerException if executor is {@code null}
       */
      public SuspendableExecutorCompletionService(SuspendableThreadPoolExecutor executor) {
          if (executor == null)
              throw new NullPointerException();
          this.executor = executor;
          this.completionQueue = new LinkedBlockingQueue<Future<V>>();
      }
  
      /**
       * Creates an ExecutorCompletionService using the supplied
       * executor for base task execution and the supplied queue as its
       * completion queue.
       *
       * @param executor the executor to use
       * @param completionQueue the queue to use as the completion queue
       *        normally one dedicated for use by this service. This
       *        queue is treated as unbounded -- failed attempted
       *        {@code Queue.add} operations for completed tasks cause
       *        them not to be retrievable.
       * @throws NullPointerException if executor or completionQueue are {@code null}
       */
      public SuspendableExecutorCompletionService(SuspendableThreadPoolExecutor executor,
                                       BlockingQueue<Future<V>> completionQueue) {
          if (executor == null || completionQueue == null)
              throw new NullPointerException();
          this.executor = executor;
          this.completionQueue = completionQueue;
      }
  
      public Future<V> submit(Callable<V> task) {
          if (task == null) throw new NullPointerException();
          RunnableFuture<V> f = newTaskFor(task);
          executor.execute(new QueueingFuture(f));
          return f;
      }
  
      public Future<V> submit(Runnable task, V result) {
          if (task == null) throw new NullPointerException();
          RunnableFuture<V> f = newTaskFor(task, result);
          executor.execute(new QueueingFuture(f));
          return f;
      }
  
      public Future<V> take() throws InterruptedException {
          return completionQueue.take();
      }
  
      public Future<V> poll() {
          return completionQueue.poll();
      }
  
      public Future<V> poll(long timeout, TimeUnit unit)
              throws InterruptedException {
          return completionQueue.poll(timeout, unit);
      }
  
  }
  