@Override public void subscribe(FlowableEmitter<Integer> e) throws Exception { e.setDisposable(d); e.onNext(1); e.onNext(2); e.onNext(3); e.onError(new TestException()); e.onComplete(); e.onNext(4); e.onError(new TestException("second")); } }, BackpressureStrategy.BUFFER)
@Override public void subscribe(FlowableEmitter<Object> e) throws Exception { FlowableEmitter<Object> f = e.serialize(); assertSame(f, f.serialize()); assertFalse(f.isCancelled()); final int[] calls = { 0 }; f.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { calls[0]++; } }); e.onComplete(); assertTrue(f.isCancelled()); assertEquals(1, calls[0]); } }, m)
@Override public void onData(List<T> data) { for (T datum : data) { if (emitter.isCancelled()) { return; } else { emitter.onNext(datum); } } if (!emitter.isCancelled()) { emitter.onComplete(); } } });
@Override public void subscribe(FlowableEmitter<Integer> s) throws Exception { calls[0]++; s.onNext(1); s.onComplete(); } }, BackpressureStrategy.MISSING);
@Override public void subscribe(FlowableEmitter<T> flowableEmitter) throws Exception { try { final T response = getSyncInvoker().method(name, entity, responseType); flowableEmitter.onNext(response); flowableEmitter.onComplete(); } catch (final Throwable throwable) { flowableEmitter.onError(throwable); } } }, BackpressureStrategy.DROP).subscribeOn(scheduler).observeOn(scheduler);
@Override public void subscribe(FlowableEmitter<T> emitter) throws Exception { try { T response = supplier.get(); if (!emitter.isCancelled()) { emitter.onNext(response); } if (!emitter.isCancelled()) { emitter.onComplete(); } } catch (Throwable e) { if (!emitter.isCancelled()) { emitter.onError(e); } } } }, BackpressureStrategy.DROP);
@Test public void verifyCancellation() { final AtomicInteger i = new AtomicInteger(); //noinspection unchecked because Java final FlowableEmitter<Integer>[] emitter = new FlowableEmitter[1]; Flowable<Integer> source = Flowable.create(e -> { e.setCancellable(i::incrementAndGet); emitter[0] = e; }, BackpressureStrategy.LATEST); CompletableSubject scope = CompletableSubject.create(); source.as(autoDisposable(scope)) .subscribe(); assertThat(i.get()).isEqualTo(0); assertThat(scope.hasObservers()).isTrue(); emitter[0].onNext(1); scope.onComplete(); emitter[0].onNext(2); // Verify cancellation was called assertThat(i.get()).isEqualTo(1); assertThat(scope.hasObservers()).isFalse(); }
@Override public boolean tryOnError(Throwable e) { if (emitter.isCancelled()) { return false; } else { emitter.onNext(Notification.<Out>createOnError(e)); return true; } }
@Override public void subscribe(final FlowableEmitter<Byte> subscriber) { while (!subscriber.isCancelled()) { try { subscriber.onNext((byte) inputStream.read()); } catch (IOException e) { connected = false; subscriber.onError(new ConnectionClosedException("Can't read stream", e)); } finally { if (!connected) { closeConnection(); } } } } }, BackpressureStrategy.BUFFER).share();
@Override public void subscribe(FlowableEmitter<File> subscriber) throws Exception { try { walk(path, 1, subscriber); if (!subscriber.isCancelled()) { subscriber.onComplete(); } } catch (final Exception ex) { if (!subscriber.isCancelled()) { subscriber.onError(ex); } } } }, BackpressureStrategy.BUFFER).toObservable();
emitter.setDisposable(disposable); emitter.setCancellable(disposable::dispose); } else { Throwable cause = f.cause(); emitter.onError( new HttpClientException("Connect error:" + cause.getMessage(), cause) );
@Override public void subscribe(FlowableEmitter<RealmResults<T>> emitter) throws Exception { Realm realm = Realm.getDefaultInstance(); RealmQuery<T> query = realm.where(clazz); if (map != null) { for (Map.Entry<String, String> entry : map.entrySet()) { query.equalTo(entry.getKey(), entry.getValue()); } } RealmResults<T> results = query.findAll(); final RealmChangeListener<RealmResults<T>> listener = _realm -> { if (!emitter.isCancelled()) { emitter.onNext(results); } }; emitter.setDisposable(Disposables.fromRunnable(() -> { results.removeChangeListener(listener); realm.close(); })); results.addChangeListener(listener); emitter.onNext(results); } }, BackpressureStrategy.LATEST);
private <T> void run( org.web3j.protocol.core.filters.Filter<T> filter, FlowableEmitter<? super T> emitter, long pollingInterval) { filter.run(scheduledExecutorService, pollingInterval); emitter.setCancellable(filter::cancel); }
@Override public void subscribe(FlowableEmitter<Object> e) throws Exception { e = e.serialize(); e.onNext(1); response[0] = e.tryOnError(new TestException()); } }, strategy)
@Override public void subscribe(FlowableEmitter<Object> s) throws Exception { for (int i = 0; i < 10; i++) { s.onNext(i); } } }, BackpressureStrategy.MISSING)
@Override public void subscribe(FlowableEmitter<Object> e) throws Exception { e.onNext(1); response[0] = e.tryOnError(new TestException()); } }, strategy)
public Flowable<CodeNode> searchInSkippedClasses(final String searchStr, final boolean caseInsensitive) { return Flowable.create(emitter -> { LOG.debug("Skipped code search started: {} ...", searchStr); for (JavaClass javaClass : skippedClasses) { String code = javaClass.getCode(); int pos = 0; while (pos != -1) { pos = searchNext(emitter, searchStr, javaClass, code, pos, caseInsensitive); if (emitter.isCancelled()) { LOG.debug("Skipped Code search canceled: {}", searchStr); return; } } if (!Utils.isFreeMemoryAvailable()) { LOG.warn("Skipped code search stopped due to memory limit: {}", Utils.memoryInfo()); emitter.onComplete(); return; } } LOG.debug("Skipped code search complete: {}, memory usage: {}", searchStr, Utils.memoryInfo()); emitter.onComplete(); }, BackpressureStrategy.LATEST); }
@Override public void subscribe(FlowableEmitter<Object> e) throws Exception { e.onError(null); } }, m)
@Override public void onComplete() { t.onComplete(); }