How to use

offer

method

in

com.oath.cyclops.async.adapters.Queue

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

@Override
public boolean addAll(final Collection<? extends T> c) {
  subscribers.forEach(it -> c.forEach(next -> it.offer(next)));
  return true;
}

@Override
public boolean add(final T e) {
  subscribers.forEach(it -> it.offer(e));
  return true;
}

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

  return Continuation.empty();
} else {
  queue.offer(local.next());

} else {
  queue.offer(local.next());

@Override
public boolean add(final T e) {
  subscribers.forEach(it -> it.offer(e));
  return true;
}

@Override
public boolean addAll(final Collection<? extends T> c) {
  subscribers.forEach(it -> c.forEach(next -> it.offer(next)));
  return true;
}

 @Override
 public void run() {
  while (events.hasNext()) {
   try {
    eventQueue.offer(events.next());
   } catch (Queue.ClosedQueueException e) {
    break;
   }
  }
  try {
   eventQueue.close();
  } catch (Queue.ClosedQueueException e) {
  }
 }
}).start();

 @Override
 public void run() {
  this.input.forEach(ievent -> {
   this.output.offer(ievent);
  });
  this.input.close();
  /*
   * When all consumers are done have the last one close the queue.
   */
  if (countdown.decrementAndGet() <= 0) {
   this.output.close();
  }
 }
}

 @Override
 public void run() {
  this.input.forEach(ievent -> {
   this.output.offer(ievent);
  });
  this.input.close();
  /*
   * When all consumers are done have the last one close the queue.
   */
  if (countdown.decrementAndGet() <= 0) {
   this.output.close();
  }
 }
}

  @Override
  default <K> void toQueue(final Map<K, Queue<U>> shards, final Function<? super U, ? extends K> sharder) {

    thenSync(it -> shards.get(sharder.apply(it))
               .offer(it)).allOf(data -> {
                 shards.values()
                    .forEach(it -> it.close());
                 return true;
               });

  }
}

 @Override
 public void run() {
  input.forEach(ievent -> {
   queues.forEach(queue -> {
    /*
     * The original event is NOT sent to each fork. Rather a copy of the event is sent to
     * each fork. This ensures that there is no contention between the operations performed
     * on each event. Caveat is that when the forks join there will be two events produced.
     */
    queue.offer(ievent.copy());
   });
  });
  for (Queue<InternalEvent> queue : queues) {
   queue.close();
  }
 }
}).start();

@Override
default <K> void toQueue(final Map<K, Queue<U>> shards, final Function<? super U, ? extends K> sharder) {
  //in this case all the items have to be pushed to the shards,
  //we can't rely on the client pulling them all to getValue them in to the right shards
  final LazyReact service = getPopulator();
  then(it -> shards.get(sharder.apply(it))
           .offer(it),
     service.getExecutor()).runThread(() -> {
       shards.values()
          .forEach(it -> it.close());
       returnPopulator(service);
     });
}

@Override
default void addToQueue(final Queue queue) {
  thenSync(it -> queue.offer(it)).allOf(it -> queue.close());
}

@Override
default Queue<U> toQueue(final Function<Queue, Queue> modifier) {
  final Queue<U> queue = modifier.apply(this.getQueueFactory()
                       .build());
  thenSync(it -> queue.offer(it)).allOf(it -> queue.close());
  return queue;
}

 @Override
 public void run() {
  for (int i = 0; i < 1000; i++) {
   if (i % 500 == 0) {
    try {
     Thread.sleep(1000);
    } catch (InterruptedException e) {
    }
   }
   q.offer(new DummyEvent("" + i, 0));
  }
  q.close();
 }
}).start();

 @Override
 public void run() {
  for (int i = 0; i < 1000; i++) {
   if (i % 500 == 0) {
    try {
     Thread.sleep(1000);
    } catch (InterruptedException e) {
    }
   }
   q.offer(new DummyEvent("" + i, 0));
  }
  q.close();
 }
}).start();

/**
 * Convert the current Stream to a SimpleReact Queue
 *
 * @return Queue populated asynchrnously by this Stream
 */
@Override
default Queue<U> toQueue() {
  final Queue<U> queue = this.getQueueFactory()
                .build();
  thenSync(it -> queue.offer(it)).allOf(it -> queue.close());
  return queue;
}

/**
 * flatten nested SimpleReactStreams
 *
 * @param stream Stream to flatten
 * @return flattened Stream
 */
static <U, R> SimpleReactStream<R> join(final SimpleReactStream<BaseSimpleReactStream<U>> stream) {
  final Queue queue = stream.getQueueFactory()
               .build();
  stream.then(it -> it.sync()
            .then(in->queue.offer(in)))
     .allOf(it -> queue.close());
  return stream.fromStream(queue.stream(stream.getSubscription()));
}