How to use com.oath.cyclops.types.reactive

/**
 * Create an Subscriber for Observable style asynchronous push based Streams.
 * Streams generated from AsyncSubscribers are not backpressure aware (in cases
 * where backpressue is not needed they may perform better).
 * For backpressure aware Streams see {@link Spouts#reactiveSubscriber}
 *
 * @param <T> Stream data type
 * @return Async Stream Subscriber
 */
static <T> AsyncSubscriber<T> asyncSubscriber(){
  return new AsyncSubscriber<T>();
}

public static <T> ValueSubscriber<T> subscriber() {
  return new ValueSubscriber<>(
                 () -> {
                 });
}

/**
 * Create a QueueBasedSubscriber, backed by a JDK LinkedBlockingQueue
 *
 * @param counter Counter for tracking connections to the queue and data volumes
 * @param maxConcurrency Maximum number of subscriptions
 * @return QueueBasedSubscriber
 */
public static <T> QueueBasedSubscriber<T> subscriber(final Counter counter, final int maxConcurrency) {
  return new QueueBasedSubscriber<>(
      counter, maxConcurrency);
}

static <T> ReactiveSeq<T> enqueuedAll(Consumer<? super Subscriber<T>>... subs){
  final Counter c = new Counter();
  c.active.set(subs.length);
  QueueBasedSubscriber<T> s = QueueBasedSubscriber.subscriber(c,subs.length);
  for(Consumer<? super Subscriber<T>> next : subs)
    next.accept(s);
  s.close();
  return s.reactiveSeq();
}
static <T> ReactiveSeq<T> enqueued(Queue<T> q,Consumer<? super Subscriber<T>> sub){

static <T> ReactiveSeq<T> enqueued(Queue<T> q,Consumer<? super Subscriber<T>> sub){
  final Counter c = new Counter();
  c.active.set(1);
  QueueBasedSubscriber<T> s = QueueBasedSubscriber.subscriber(q,c,1);
  sub.accept(s);
  return s.reactiveSeq();
}
static <T> ReactiveSeq<T> enqueued(QueueFactory<T> factory, Consumer<? super Subscriber<T>>... subs){

@Override
public Subscriber<Long> createSubscriber() {
  return new QueueBasedSubscriber(new QueueBasedSubscriber.Counter(),500);
}

  @Override
  public void onComplete() {
    PushSubscriber.this.onComplete();
  }
};

@Override
public void onNext(T t) {
  PushSubscriber.this.onNext(t);
}

@Override
default <X extends Throwable> Subscription forEachSubscribe(Consumer<? super T> consumer, Consumer<? super Throwable> consumerError){
  Subscription result = ReactiveStreamsTerminalOperations.super.forEachSubscribe(consumer,consumerError,()->{});
  return result;
}

/**
 * Request all elements to be processed from the processing Stream
 */
public void requestAll() {
  request(Long.MAX_VALUE);
}

/**
 * Request all elements to be processed asynchronously in the processing stream
 *
 * @return New ReactiveTask that references the execution of the new async task
 */
public ReactiveTask requestAllAsync() {
  return requestAsync(Long.MAX_VALUE);
}

@Override
public void onError(Throwable t) {
  PushSubscriber.this.onError(t);
}

/**
 *   The recommended way to connect a Spout to a Publisher is via Spouts#from
 *   Create an Subscriber for Observable style asynchronous push based Streams,
 *   that implements backpressure internally via the reactive-streams spec.
 *
 *   Subscribers signal demand via their subscription and publishers push data to subscribers
 *   synchronously or asynchronously, never exceeding signalled demand
 *
 * @param <T> Stream data type
 * @return An async Stream Subscriber that supports efficient backpressure via reactive-streams
 */
static <T> ReactiveSubscriber<T> reactiveSubscriber(){
  return new ReactiveSubscriber<T>();
}

@Override
public void onNext(Long aLong) {
  probe.registerOnNext(aLong);
  super.onNext(aLong);
}

  @Override
  public void onComplete() {
    probe.registerOnComplete();
    super.onComplete();
  }
};

static <T> ReactiveSeq<T> enqueued(QueueFactory<T> factory, Consumer<? super Subscriber<T>>... subs){
  final Counter c = new Counter();
  c.active.set(subs.length);
  QueueBasedSubscriber<T> s = QueueBasedSubscriber.subscriber(factory,c,subs.length);
  for(Consumer<? super Subscriber<T>> next : subs)
    next.accept(s);
  return s.reactiveSeq();
}

/**
 * Create a QueueBasedSubscriber, backed by the provided Queue
 *
 * @param q Queue backing the reactiveSubscriber
 * @param counter Counter for tracking connections to the queue and data volumes
 * @param maxConcurrency Maximum number of subscriptions
 * @return QueueBasedSubscriber
 */
public static <T> QueueBasedSubscriber<T> subscriber(final Queue<T> q, final Counter counter, final int maxConcurrency) {
  return new QueueBasedSubscriber<>(
      q, counter, maxConcurrency);
}

public static <T> ValueSubscriber<T> subscriber(final Runnable onComplete) {
  return new ValueSubscriber<>(
                 onComplete);
}

@Override
default <X extends Throwable> Subscription forEachSubscribe(Consumer<? super T> consumer, Consumer<? super Throwable> consumerError, Runnable onComplete){
  Subscription result = ReactiveStreamsTerminalOperations.super.forEachSubscribe(consumer,consumerError,onComplete);
  return result;
}
@Override

/**
 * Create a QueueBasedSubscriber, backed by a Queue that will be created with the provided QueueFactory
 *
 * @param factory QueueFactory
 * @param counter Counter for tracking connections to the queue and data volumes
 * @param maxConcurrency Maximum number of subscriptions
 * @return QueueBasedSubscriber
 */
public static <T> QueueBasedSubscriber<T> subscriber(final QueueFactory<T> factory, final Counter counter, final int maxConcurrency) {
  return new QueueBasedSubscriber<>(
      factory, counter, maxConcurrency);
}