public void forEachRemaining(Consumer<? super T> action) { if(async || active) Iterator.super.forEachRemaining(action); else source.subscribeAll(action,defaultErrorHandler,()->{}); }
@Override public void subscribeAll(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onCompleteDs) { source.subscribeAll(onNext, onError, () -> { complete.run(); onCompleteDs.run(); }); }
@Override public void subscribeAll(Consumer<? super R> onNext, Consumer<? super Throwable> onError, Runnable onCompleteDs) { source.subscribeAll(e-> { try { onNext.accept(mapper.apply(e)); } catch (Throwable t) { onError.accept(t); } } ,onError,onCompleteDs); } }
@Override public void subscribeAll(Consumer<? super R> onNext, Consumer<? super Throwable> onError, Runnable onCompleteDs) { source.subscribeAll(e-> { try { mapper.apply(e).forEach(onNext); } catch (Throwable t) { onError.accept(t); } } ,onError,onCompleteDs); } }
@Override public void subscribeAll(Consumer<? super R> onNext, Consumer<? super Throwable> onError, Runnable onCompleteDs) { Function<? super T, ? extends R> mapper = mapperSupplier.get(); source.subscribeAll(e-> { try { onNext.accept(mapper.apply(e)); } catch (Throwable t) { onError.accept(t); } } ,onError,onCompleteDs); } }
@Override public void subscribeAll(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onCompleteDs) { boolean[] data ={ false}; source.subscribeAll(e->{ if(!data[0]) data[0]=true; onNext.accept(e); } ,onError,()->{ if(data[0]==false) onError.accept(value.get()); onCompleteDs.run(); }); } }
@Override public void subscribeAll(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onCompleteDs) { Predicate<? super T> predicate = predicateSupplier.get(); source.subscribeAll(e-> { try { if(predicate.test(e)) onNext.accept(e); } catch (Throwable t) { onError.accept(t); } } ,onError,onCompleteDs); } }
@Override public void subscribeAll(Consumer<? super IN> onNext, Consumer<? super Throwable> onError, Runnable onComplete) { if(racers.length==1){ racers[0].subscribeAll(onNext,onError,onComplete); }else{ activeRacers = Seq.empty(); for(Operator<IN> next : racers){ Racer racer = new Racer(onNext,onError,onComplete); next.subscribeAll(racer::onNext, racer::onError, racer::onComplete); activeRacers = activeRacers.plus(racer); } } }
@Override public void forEachAsync(final Consumer<? super T> action) { if (async == Type.NO_BACKPRESSURE) source.subscribeAll(action, this.defaultErrorHandler, () -> { }); else source.subscribe(action, this.defaultErrorHandler, () -> { }).request(Long.MAX_VALUE); }
@Override public <X extends Throwable> void forEach(final Consumer<? super T> consumerElement, final Consumer<? super Throwable> consumerError) { if (async != Type.NO_BACKPRESSURE) { this.source.subscribe(consumerElement, consumerError, () -> { }).request(Long.MAX_VALUE); } else { source.subscribeAll(consumerElement, consumerError, () -> { }); } }
@Override public <X extends Throwable> void forEach(final Consumer<? super T> consumerElement, final Consumer<? super Throwable> consumerError, final Runnable onComplete) { if (async != Type.NO_BACKPRESSURE) { this.source.subscribe(consumerElement, consumerError, onComplete).request(Long.MAX_VALUE); } else { source.subscribeAll(consumerElement, consumerError, onComplete); } }
public void subscribeAll(int index,Consumer<? super IN> onNext, Consumer<? super Throwable> onError, Runnable onCompleteDs) { if(index>=operators.size()) { onCompleteDs.run(); return; } Operator<IN> next = operators.getOrElse(index,null); next.subscribeAll(onNext,onError,()->subscribeAll(index+1,onNext,onError,onCompleteDs)); } }
@Override public void subscribeAll(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onCompleteDs) { registeredOnNext= registeredOnNext.plus(onNext); registeredOnError = registeredOnError.plus(onError); registeredOnComplete=registeredOnComplete.plus(onCompleteDs); source.subscribeAll(e -> { registeredOnNext.forEach(n -> n.accept(e)); } , e -> registeredOnError.forEach(t -> t.accept(e)), () -> registeredOnComplete.forEach(n -> n.run())); } }
@Test public void subscribeAllTwoAndError() throws Exception { twoAndError.subscribeAll(values::add,errors::add,()->onComplete =true); assertThat(values.size(),equalTo( 2)); assertThat(errors.size(),equalTo(1)); assertTrue(onComplete); } @Test
@Test public void subscribeAllThreeErrors() throws Exception { threeErrors.subscribeAll(values::add,errors::add,()->onComplete =true); assertThat(values.size(),equalTo( 0)); assertThat(errors.size(),equalTo(3)); assertTrue(onComplete); }
@Test public void subscribeAllEmpty() throws Exception { empty.subscribeAll(values::add,errors::add,()->onComplete =true); assertThat(values.size(),equalTo(0)); assertThat(errors.size(),equalTo(0)); assertTrue(onComplete); } @Test
@Test public void subscribeAllOne() throws Exception { one.subscribeAll(values::add,errors::add,()->onComplete =true); assertThat(values.size(),equalTo( 1)); assertThat(errors.size(),equalTo(0)); assertTrue(onComplete); }
@Test public void subscribeAllThree() throws Exception { three.subscribeAll(values::add,errors::add,()->onComplete =true); assertThat(values.size(),equalTo( 3)); assertThat(errors.size(),equalTo(0)); assertTrue(onComplete); } @Test
@Override public void forEachOrdered(final Consumer<? super T> consumer) { Future<Boolean> complete = Future.future(); if (async == Type.NO_BACKPRESSURE) { source.subscribeAll(consumer, this.defaultErrorHandler, () -> complete.complete(true)); } else { source.subscribe(consumer, this.defaultErrorHandler, () -> complete.complete(true)).request(Long.MAX_VALUE); } complete.get(); }
@Override public void forEach(final Consumer<? super T> action) { Future<Boolean> complete = Future.future(); if (async == Type.NO_BACKPRESSURE) { source.subscribeAll(action, this.defaultErrorHandler, () -> complete.complete(true)); } else { source.subscribe(action, this.defaultErrorHandler, () -> complete.complete(true)).request(Long.MAX_VALUE); } complete.get(); }