@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())); }