com.outbrain.ob1k.concurrent.combiners.Combiner Maven / Gradle / Ivy

Go to download
package com.outbrain.ob1k.concurrent.combiners;

import com.outbrain.ob1k.concurrent.*;
import com.outbrain.ob1k.concurrent.handlers.FutureSuccessHandler;
import com.outbrain.ob1k.concurrent.handlers.SuccessHandler;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicReferenceArray;

import static com.outbrain.ob1k.concurrent.ComposableFutures.fromValue;
import static com.outbrain.ob1k.concurrent.ComposableFutures.schedule;

/**
 * combines two or more futures into one.
 *
 * @author aronen on 9/2/14.
 */
public class Combiner {

  public static  ComposableFuture any(final Iterable> elements) {
    return ComposableFutures.build(new Producer() {
      @Override
      public void produce(final Consumer consumer) {
        final AtomicBoolean done = new AtomicBoolean();
        for (final ComposableFuture future : elements) {
          future.consume(new Consumer() {
            @Override
            public void consume(final Try result) {
              if (done.compareAndSet(false, true)) {
                consumer.consume(result);
              }
            }
          });
        }
      }
    });
  }

  public static  ComposableFuture> all(final boolean failOnError, final Iterable> elements) {
    final Map> elementsMap = new HashMap<>();
    int index = 0;
    for (final ComposableFuture element : elements) {
      elementsMap.put(index++, element);
    }

    return all(failOnError, elementsMap).continueOnSuccess(new SuccessHandler, List>() {
      @Override
      public List handle(final Map result) {
        return new ArrayList<>(result.values());
      }
    });
  }

  public static  ComposableFuture> all(final boolean failOnError, final Map> elements) {
    return first(elements, elements.size(), failOnError, null, null);
  }

  private static class Status {
    final int total;
    final int minSuccessful;

    final int results;
    final int successfulResults;
    final boolean finished;

    private Status(final int total, final int minSuccessful,
                   final int results, final int successfulResults,
                   final boolean finished) {
      this.total = total;
      this.minSuccessful = minSuccessful;
      this.results = results;
      this.successfulResults = successfulResults;
      this.finished = finished;
    }

    boolean isDone() {
      return finished || results == total || successfulResults >= minSuccessful;
    }
  }

  private static class KeyValue {
    final K key;
    final V value;

    private KeyValue(final K key, final V value) {
      this.key = key;
      this.value = value;
    }
  }

  public static  ComposableFuture> first(final Map> elements, final int numOfSuccess,
                                                         final boolean failOnError, final Long timeout, final TimeUnit timeUnit) {

    if (elements.isEmpty()) {
      final Map empty = new HashMap<>();
      return fromValue(empty);
    }

    return ComposableFutures.build(new Producer>() {
      @Override
      public void produce(final Consumer> consumer) {
        final AtomicReferenceArray> results = new AtomicReferenceArray<>(elements.size());
        final AtomicReference status = new AtomicReference<>(new Status(elements.size(), numOfSuccess, 0, 0, false));
        int counter = 0;

        if (timeout != null) {
          schedule(new Callable