How to use com.oath.cyclops.async.adapters

/**
 * @return Signal backed by a topic
 */
public static <T> Signal<T> topicBackedSignal() {
  return new Signal(
           new Topic<>(), new Topic<>());
}

/**
 * Generating a streamCompletableFutures will register the Stream as a reactiveSubscriber to this topic.
 * It will be provided with an internal Queue as a mailbox. @see Topic.disconnect to disconnect from the topic
 *
 * @return Stream of CompletableFutures that can be used as input into a SimpleReact concurrent dataflow
 */
@Override
public ReactiveSeq<CompletableFuture<T>> streamCompletableFutures() {
  return connect(q -> q.streamCompletableFutures());
}

public static <T> Queue<T> createMergeQueue() {
  final Queue<T> q = new Queue<>();
  q.continuationStrategy = new AdaptersModule.StreamOfContinuations(
                            q);
  return q;
}

/**
 * @return Signal backed by a queue
 */
public static <T> Signal<T> queueBackedSignal() {
  return new Signal<T>(
             new Queue<T>(
                   new LinkedBlockingQueue<T>(), null),
             new Queue<T>(
                   new LinkedBlockingQueue<T>(), null));
}

/**
 * Construct a new Topic
 */
public Topic() {
  final Queue<T> q = new Queue<T>();
  factory = QueueFactories.unboundedQueue();
  distributor.addQueue(q);
}

private Queue<T> getNextQueue() {
  if (index >= this.distributor.getSubscribers()
                 .size()) {
    this.distributor.addQueue(factory.build());
  }
  return this.distributor.getSubscribers()
              .getOrElse(index++,null);
}

@Override
public ReactiveSeq<T> stream(final Continueable s) {
  return connect(q -> q.stream(s));
}

@Override
public boolean offer(T t) {
  return host.offer(t);
}

/**
 * Set the current value of this signal
 *
 * @param newValue Replacement value
 * @return newValue
 */
public T set(final T newValue) {
  if(continuous!=null)
   continuous.offer(newValue);
  setDiscreteIfDiff(newValue);
  return newValue;
}

public void addContinuation(final Continuation c) {
  if (this.continuationStrategy == null)
    continuationStrategy = new AdaptersModule.SingleContinuation(
                           this);
  this.continuationStrategy.addContinuation(c);
}

@Override
public int size() {
  return host.size();
}

public void setSizeSignal(final int index, final Signal<Integer> s) {
  this.distributor.getSubscribers()
          .getOrElse(index, null)
          .setSizeSignal(s);
}

/**
 * Close this Signal
 *
 *
 */
public void close() {
  if(continuous!=null)
   continuous.close();
  discrete.close();
}

private T ensureNotPoisonPill(final T data) {
  if (data instanceof PoisonPill) {
    throw new ClosedQueueException();
  }
  return data;
}

@Override
public T poll() {
  return host.get();
}

@Override
public Spliterator<T> trySplit() {
  return new ClosingSpliterator<T>(
      estimate >>>= 1, s, subscription, queue,closed);
}

public Queue(final java.util.Queue<T> q, final WaitStrategy<T> consumer, final WaitStrategy<T> producer) {
  this(new AdaptersModule.QueueToBlockingQueueWrapper(
                     q),
     consumer, producer);
}

@Override
public Object poll(final long timeout, final TimeUnit unit) throws InterruptedException {
  return poll();
}

public Topic(final Queue<T> q,QueueFactory<T> factory) {
  this.factory = factory;
  distributor.addQueue(q);
}

/**
 * Generating a stream will register the Stream as a reactiveSubscriber to this topic.
 * It will be provided with an internal Queue as a mailbox. @see Topic.disconnect to disconnect from the topic
 * @return Stream of data
 */
@Override
public ReactiveSeq<T> stream() {
  return connect(q -> q.stream());
}