/** * Convert an {@link PushStream} into an {@link PushEventSource}. The first * call to {@link PushEventSource#open(PushEventConsumer)} will begin event * processing. The {@link PushEventSource} will remain active until the * backing stream is closed, and permits multiple consumers to * {@link PushEventSource#open(PushEventConsumer)} it. This is equivalent * to: * * <pre> * buildEventSourceFromStream(stream).create(); * </pre> * * @param stream * @return a {@link PushEventSource} backed by the {@link PushStream} */ public <T> PushEventSource<T> createEventSourceFromStream( PushStream<T> stream) { return buildEventSourceFromStream(stream).build(); }
@Override public <U extends BlockingQueue<PushEvent< ? extends T>>> PushStreamBuilder<T,U> buildBuffer() { return psp.buildStream(c -> { forEachEvent(c); return this; }); }
@Override public SimplePushEventSource<T> build() { return createSimplePushEventSource(concurrency, worker, buffer, bufferingPolicy, () -> { /* Nothing else to do */ }); } };
@Override public PushStream<T> build() { Executor workerToUse = worker == null ? previousExecutor : worker; ScheduledExecutorService timerToUse = timer == null ? previousScheduler : timer; if (unbuffered) { return psp.createUnbufferedStream(eventSource, workerToUse, timerToUse); } else { return psp.createStream(eventSource, concurrency, workerToUse, timerToUse, buffer, bufferingPolicy, backPressure); } } }
ScheduledExecutorService timerToUse; if (scheduler == null) { timerToUse = acquireScheduler(); releaseSchedulerOnClose = true; } else { return cleanupThreads(closeExecutorOnClose, workerToUse, releaseSchedulerOnClose, stream);
new PromiseFactory(toUse, acquireScheduler()), queuePolicy, queue, parallelism, () -> { ((ExecutorService) toUse).shutdown(); releaseScheduler(); }); return spes;
@Override public PushStream<T> buffer() { return psp.createStream(c -> { forEachEvent(c); return this; }); }
private <T> PushStream<T> cleanupThreads(boolean closeExecutorOnClose, Executor workerToUse, boolean releaseSchedulerOnClose, PushStream<T> stream) { if (closeExecutorOnClose || releaseSchedulerOnClose) { stream = stream.onClose(() -> { if (closeExecutorOnClose) { ((ExecutorService) workerToUse).shutdown(); } if (releaseSchedulerOnClose) { releaseScheduler(); } }).map(x -> x); } return stream; }
/** * Create a buffered {@link PushEventConsumer} with the default configured * buffer, executor size, queue, queue policy and pushback policy. This is * equivalent to calling * * <pre> * buildBufferedConsumer(delegate).create(); * </pre> * <p> * The returned consumer will be buffered from the event source, and will * honor back pressure requests from its delegate even if the event source * does not. * <p> * Buffered consumers are useful for "bursty" event sources which produce a * number of events close together, then none for some time. These bursts * can sometimes overwhelm the consumer. Buffering will not, however, * protect downstream components from a source which produces events faster * than they can be consumed. * * @param delegate * @return a {@link PushEventConsumer} with a buffer directly before it */ public <T> PushEventConsumer<T> createBufferedConsumer( PushEventConsumer<T> delegate) { return buildBufferedConsumer(delegate).build(); }
}; return this.<T> createUnbufferedStream(pes, null, null);
ScheduledExecutorService timerToUse; if (scheduler == null) { timerToUse = acquireScheduler(); releaseSchedulerOnClose = true; } else { return cleanupThreads(closeExecutorOnClose, workerToUse, releaseSchedulerOnClose, stream);
@Override public PushStream<T> build() { Executor workerToUse = worker == null ? previousExecutor : worker; ScheduledExecutorService timerToUse = timer == null ? previousScheduler : timer; if (unbuffered) { return psp.createUnbufferedStream(eventSource, workerToUse, timerToUse); } else { return psp.createStream(eventSource, concurrency, workerToUse, timerToUse, buffer, bufferingPolicy, backPressure); } } }
new PromiseFactory(toUse, acquireScheduler()), queuePolicy, queue, parallelism, () -> { ((ExecutorService) toUse).shutdown(); releaseScheduler(); }); return spes;
@Override public PushStream<T> buffer() { return psp.createStream(c -> { forEachEvent(c); return this; }); }
private <T> PushStream<T> cleanupThreads(boolean closeExecutorOnClose, Executor workerToUse, boolean releaseSchedulerOnClose, PushStream<T> stream) { if (closeExecutorOnClose || releaseSchedulerOnClose) { stream = stream.onClose(() -> { if (closeExecutorOnClose) { ((ExecutorService) workerToUse).shutdown(); } if (releaseSchedulerOnClose) { releaseScheduler(); } }).map(x -> x); } return stream; }
/** * Create a buffered {@link PushEventConsumer} with the default configured * buffer, executor size, queue, queue policy and pushback policy. This is * equivalent to calling * * <pre> * buildBufferedConsumer(delegate).create(); * </pre> * <p> * The returned consumer will be buffered from the event source, and will * honor back pressure requests from its delegate even if the event source * does not. * <p> * Buffered consumers are useful for "bursty" event sources which produce a * number of events close together, then none for some time. These bursts * can sometimes overwhelm the consumer. Buffering will not, however, * protect downstream components from a source which produces events faster * than they can be consumed. * * @param delegate * @return a {@link PushEventConsumer} with a buffer directly before it */ public <T> PushEventConsumer<T> createBufferedConsumer( PushEventConsumer<T> delegate) { return buildBufferedConsumer(delegate).build(); }
}; return this.<T> createUnbufferedStream(pes, null, null);
ScheduledExecutorService timerToUse; if (scheduler == null) { timerToUse = acquireScheduler(); releaseSchedulerOnClose = true; } else { return cleanupThreads(closeExecutorOnClose, workerToUse, releaseSchedulerOnClose, stream);
@Override public PushStream<T> build() { Executor workerToUse = worker == null ? previousExecutor : worker; ScheduledExecutorService timerToUse = timer == null ? previousScheduler : timer; if (unbuffered) { return psp.createUnbufferedStream(eventSource, workerToUse, timerToUse); } else { return psp.createStream(eventSource, concurrency, workerToUse, timerToUse, buffer, bufferingPolicy, backPressure); } } }
new PromiseFactory(toUse, acquireScheduler()), queuePolicy, queue, parallelism, () -> { ((ExecutorService) toUse).shutdown(); releaseScheduler(); }); return spes;