/**@class java.util.concurrent.ExecutorCompletionService
 implements java.util.concurrent.CompletionService

@extends java.lang.Object

 A {@link java.util.concurrent.CompletionService} that uses a supplied {@link java.util.concurrent.Executor}
 to execute tasks.  This class arranges that submitted tasks are,
 upon completion, placed on a queue accessible using {@code take}.
 The class is lightweight enough to be suitable for transient use
 when processing groups of tasks.

 <p>

 <b>Usage Examples.</b>

 Suppose you have a set of solvers for a certain problem, each
 returning a value of some type {@code Result}, and would like to
 run them concurrently, processing the results of each of them that
 return a non-null value, in some method {@code use(Result r)}. You
 could write this as:

 <pre> {@code
 void solve(Executor e,
            Collection<Callable<Result>> solvers)
     throws InterruptedException, ExecutionException {
   CompletionService<Result> ecs
       = new ExecutorCompletionService<Result>(e);
   for (Callable<Result> s : solvers)
     ecs.submit(s);
   int n = solvers.size();
   for (int i = 0; i < n; ++i) {
     Result r = ecs.take().get();
     if (r != null)
       use(r);
   }
 }}</pre>

 Suppose instead that you would like to use the first non-null result
 of the set of tasks, ignoring any that encounter exceptions,
 and cancelling all other tasks when the first one is ready:

 <pre> {@code
 void solve(Executor e,
            Collection<Callable<Result>> solvers)
     throws InterruptedException {
   CompletionService<Result> ecs
       = new ExecutorCompletionService<Result>(e);
   int n = solvers.size();
   List<Future<Result>> futures = new ArrayList<>(n);
   Result result = null;
   try {
     for (Callable<Result> s : solvers)
       futures.add(ecs.submit(s));
     for (int i = 0; i < n; ++i) {
       try {
         Result r = ecs.take().get();
         if (r != null) {
           result = r;
           break;
         }
       } catch (ExecutionException ignore) {}
     }
   }
   finally {
     for (Future<Result> f : futures)
       f.cancel(true);
   }

   if (result != null)
     use(result);
 }}</pre>
*/
var ExecutorCompletionService = {

/**
*/
submit : function(  ) {},

/**
*/
submit : function(  ) {},

/**
*/
take : function(  ) {},

/**
*/
poll : function(  ) {},

/**
*/
poll : function(  ) {},


};