subscription.request(1); } else { LOGGER.finest(() -> "Ending stream: " + Optional.ofNullable(chunk).map(DataChunk::id).orElse(null));
@Override public void cancel() { try { subscribedLatch.await(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } mySubscription.cancel(); } };
subscription.request(1); } else { LOGGER.finest(() -> "Ending stream: " + Optional.ofNullable(chunk).map(DataChunk::id).orElse(null));
@Override public int read() throws IOException { try { while (true) { ByteBuffer currentBuffer = processed.get(); // block until a processing data are available if (currentBuffer != null && currentBuffer.remaining() > 0) { // if there is anything to read, then read one byte... return currentBuffer.get(); } else if (!closed.get()) { // reinitialize the processed buffer future and request more data processed = new CompletableFuture<>(); subscription.request(1); } else { // else we have read all the data already and the data inflow has completed return -1; } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new IOException(e); } catch (ExecutionException e) { throw new IOException(e.getCause()); } }
@Override public void resume() { boolean processDemand = false; lock.lock(); try { if (paused && subscriber != null) { paused = false; if (recordedDemand) { processDemand = true; recordedDemand = false; } } } finally { lock.unlock(); if (processDemand) { subscriber.subscription.request(1); } } }
@Override public void onNext(ByteBuffer dataBuffer) { try { if (dataBuffer.hasArray()) { outputStream.write( dataBuffer.array(), dataBuffer.arrayOffset() + dataBuffer.position(), dataBuffer.remaining()); } else { byte[] data = new byte[dataBuffer.remaining()]; outputStream.write(data); } subscription.request(1); } catch (IOException e) { throw new IllegalStateException(e); } }
@Override public void request(long n) { subscription.request(n); }
private void cancelSubscription() { subscription.cancel(); } }
@Override public void onSubscribe(Flow.Subscription subscription) { this.subscription = subscription; subscription.request(Long.MAX_VALUE); }
@Override public void onSubscribe(Flow.Subscription subscription) { this.subscription = subscription; subscription.request(1); }
@Override public void onComplete() { completeInternal(null); if (subscription != null) { subscription.cancel(); } }
@Override public void onError(Throwable thr) { completeInternal(thr); if (subscription != null) { subscription.cancel(); } }
@Override public void onNext(ConfigDiff event) { //(3. fire just on case the sub-node has changed) if (event.changedKeys().contains(AbstractConfigImpl.this.realKey)) { delegate.onNext(AbstractConfigImpl.this.contextConfig(event.config())); } else { subscription.request(1); } }
@Override public void onSubscribe(Flow.Subscription subscription) { logger.finest(() -> "onSubscribe: " + subscription); this.subscription = subscription; subscription.request(Long.MAX_VALUE); }
@Override public void onNext(ConfigDiff event) { if (ConfigFactory.this.config() == event.config()) { //ignore events about current Config instance //missed event must be requested once more subscription.request(1); } else { delegate.onNext(event); } }
@Override public void onSubscribe(Flow.Subscription subscription) { this.subscription = subscription; subscription.request(Long.MAX_VALUE); }
@Override public void onSubscribe(Flow.Subscription subscription) { this.subscription = subscription; subscription.request(Long.MAX_VALUE); }
@Override public void request(long n) { beforeRequestHook.run(); subscription.request(n); }
@Override public void onNext(T item) { boolean cancel = !onNextFunction.apply(item); logger.finest(() -> "onNext: " + item + " => " + (cancel ? "CANCEL" : "FOLLOW")); if (cancel) { subscription.cancel(); } }
@Override public void cancel() { try { subscribedLatch.await(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } mySubscription.cancel(); } };