From be2ed7f7a97e9f467e4b62abe8a5827fa861e431 Mon Sep 17 00:00:00 2001 From: akarnokd+ci Date: Fri, 29 Sep 2023 08:41:36 +0000 Subject: [PATCH] CI build: 33 for 3.1.8 --- 3.x/javadoc/3.1.8/allclasses-frame.html | 158 + 3.x/javadoc/3.1.8/allclasses-noframe.html | 158 + 3.x/javadoc/3.1.8/constant-values.html | 262 + 3.x/javadoc/3.1.8/deprecated-list.html | 121 + 3.x/javadoc/3.1.8/help-doc.html | 222 + 3.x/javadoc/3.1.8/index-all.html | 11734 +++++++ 3.x/javadoc/3.1.8/index.html | 75 + .../rxjava3/annotations/BackpressureKind.html | 415 + .../annotations/BackpressureSupport.html | 223 + .../reactivex/rxjava3/annotations/Beta.html | 162 + .../rxjava3/annotations/CheckReturnValue.html | 169 + .../rxjava3/annotations/Experimental.html | 162 + .../rxjava3/annotations/NonNull.html | 164 + .../rxjava3/annotations/Nullable.html | 164 + .../rxjava3/annotations/SchedulerSupport.html | 396 + .../rxjava3/annotations/package-frame.html | 29 + .../rxjava3/annotations/package-summary.html | 209 + .../rxjava3/annotations/package-tree.html | 148 + .../core/BackpressureOverflowStrategy.html | 362 + .../rxjava3/core/BackpressureStrategy.html | 396 + .../reactivex/rxjava3/core/Completable.html | 5392 +++ .../rxjava3/core/CompletableConverter.html | 244 + .../rxjava3/core/CompletableEmitter.html | 373 + .../rxjava3/core/CompletableObserver.html | 301 + .../rxjava3/core/CompletableOnSubscribe.html | 237 + .../rxjava3/core/CompletableOperator.html | 238 + .../rxjava3/core/CompletableSource.html | 243 + .../rxjava3/core/CompletableTransformer.html | 236 + .../io/reactivex/rxjava3/core/Emitter.html | 280 + .../io/reactivex/rxjava3/core/Flowable.html | 28606 ++++++++++++++++ .../rxjava3/core/FlowableConverter.html | 245 + .../rxjava3/core/FlowableEmitter.html | 397 + .../rxjava3/core/FlowableOnSubscribe.html | 241 + .../rxjava3/core/FlowableOperator.html | 243 + .../rxjava3/core/FlowableSubscriber.html | 268 + .../rxjava3/core/FlowableTransformer.html | 242 + .../io/reactivex/rxjava3/core/Maybe.html | 9347 +++++ .../rxjava3/core/MaybeConverter.html | 246 + .../reactivex/rxjava3/core/MaybeEmitter.html | 404 + .../reactivex/rxjava3/core/MaybeObserver.html | 342 + .../rxjava3/core/MaybeOnSubscribe.html | 241 + .../reactivex/rxjava3/core/MaybeOperator.html | 243 + .../reactivex/rxjava3/core/MaybeSource.html | 250 + .../rxjava3/core/MaybeTransformer.html | 242 + .../reactivex/rxjava3/core/Notification.html | 478 + .../io/reactivex/rxjava3/core/Observable.html | 24457 +++++++++++++ .../rxjava3/core/ObservableConverter.html | 245 + .../rxjava3/core/ObservableEmitter.html | 375 + .../rxjava3/core/ObservableOnSubscribe.html | 241 + .../rxjava3/core/ObservableOperator.html | 243 + .../rxjava3/core/ObservableSource.html | 247 + .../rxjava3/core/ObservableTransformer.html | 242 + .../io/reactivex/rxjava3/core/Observer.html | 367 + .../rxjava3/core/Scheduler.Worker.html | 450 + .../io/reactivex/rxjava3/core/Scheduler.html | 696 + .../io/reactivex/rxjava3/core/Single.html | 8670 +++++ .../rxjava3/core/SingleConverter.html | 245 + .../reactivex/rxjava3/core/SingleEmitter.html | 386 + .../rxjava3/core/SingleObserver.html | 325 + .../rxjava3/core/SingleOnSubscribe.html | 241 + .../rxjava3/core/SingleOperator.html | 243 + .../reactivex/rxjava3/core/SingleSource.html | 250 + .../rxjava3/core/SingleTransformer.html | 242 + .../reactivex/rxjava3/core/package-frame.html | 69 + .../rxjava3/core/package-summary.html | 516 + .../reactivex/rxjava3/core/package-tree.html | 199 + .../disposables/CompositeDisposable.html | 511 + .../rxjava3/disposables/Disposable.html | 506 + .../disposables/DisposableContainer.html | 286 + .../rxjava3/disposables/SerialDisposable.html | 412 + .../rxjava3/disposables/package-frame.html | 25 + .../rxjava3/disposables/package-summary.html | 187 + .../rxjava3/disposables/package-tree.html | 140 + .../exceptions/CompositeException.html | 472 + .../rxjava3/exceptions/Exceptions.html | 283 + .../MissingBackpressureException.html | 380 + .../OnErrorNotImplementedException.html | 307 + .../ProtocolViolationException.html | 281 + .../exceptions/QueueOverflowException.html | 291 + .../exceptions/UndeliverableException.html | 282 + .../rxjava3/exceptions/package-frame.html | 28 + .../rxjava3/exceptions/package-summary.html | 211 + .../rxjava3/exceptions/package-tree.html | 156 + .../flowables/ConnectableFlowable.html | 821 + .../rxjava3/flowables/GroupedFlowable.html | 320 + .../rxjava3/flowables/package-frame.html | 20 + .../rxjava3/flowables/package-summary.html | 161 + .../rxjava3/flowables/package-tree.html | 139 + .../reactivex/rxjava3/functions/Action.html | 232 + .../rxjava3/functions/BiConsumer.html | 244 + .../rxjava3/functions/BiFunction.html | 251 + .../rxjava3/functions/BiPredicate.html | 248 + .../rxjava3/functions/BooleanSupplier.html | 234 + .../rxjava3/functions/Cancellable.html | 233 + .../reactivex/rxjava3/functions/Consumer.html | 240 + .../reactivex/rxjava3/functions/Function.html | 244 + .../rxjava3/functions/Function3.html | 251 + .../rxjava3/functions/Function4.html | 255 + .../rxjava3/functions/Function5.html | 259 + .../rxjava3/functions/Function6.html | 263 + .../rxjava3/functions/Function7.html | 267 + .../rxjava3/functions/Function8.html | 271 + .../rxjava3/functions/Function9.html | 275 + .../rxjava3/functions/IntFunction.html | 240 + .../rxjava3/functions/LongConsumer.html | 234 + .../rxjava3/functions/Predicate.html | 242 + .../reactivex/rxjava3/functions/Supplier.html | 250 + .../rxjava3/functions/package-frame.html | 37 + .../rxjava3/functions/package-summary.html | 263 + .../rxjava3/functions/package-tree.html | 148 + .../observables/ConnectableObservable.html | 781 + .../observables/GroupedObservable.html | 320 + .../rxjava3/observables/package-frame.html | 20 + .../rxjava3/observables/package-summary.html | 161 + .../rxjava3/observables/package-tree.html | 139 + .../rxjava3/observers/BaseTestConsumer.html | 1175 + .../rxjava3/observers/DefaultObserver.html | 372 + .../DisposableCompletableObserver.html | 388 + .../observers/DisposableMaybeObserver.html | 402 + .../rxjava3/observers/DisposableObserver.html | 406 + .../observers/DisposableSingleObserver.html | 395 + .../LambdaConsumerIntrospection.html | 235 + .../ResourceCompletableObserver.html | 437 + .../observers/ResourceMaybeObserver.html | 452 + .../rxjava3/observers/ResourceObserver.html | 449 + .../observers/ResourceSingleObserver.html | 445 + .../rxjava3/observers/SafeObserver.html | 435 + .../rxjava3/observers/SerializedObserver.html | 468 + .../rxjava3/observers/TestObserver.html | 626 + .../rxjava3/observers/package-frame.html | 35 + .../rxjava3/observers/package-summary.html | 292 + .../rxjava3/observers/package-tree.html | 153 + .../operators/ConditionalSubscriber.html | 263 + .../rxjava3/operators/QueueDisposable.html | 261 + .../rxjava3/operators/QueueFuseable.html | 411 + .../rxjava3/operators/QueueSubscription.html | 264 + .../rxjava3/operators/ScalarSupplier.html | 258 + .../rxjava3/operators/SimplePlainQueue.html | 261 + .../rxjava3/operators/SimpleQueue.html | 354 + .../rxjava3/operators/SpscArrayQueue.html | 442 + .../operators/SpscLinkedArrayQueue.html | 463 + .../rxjava3/operators/package-frame.html | 30 + .../rxjava3/operators/package-summary.html | 216 + .../rxjava3/operators/package-tree.html | 177 + .../parallel/ParallelFailureHandling.html | 409 + .../rxjava3/parallel/ParallelFlowable.html | 2620 ++ .../parallel/ParallelFlowableConverter.html | 246 + .../rxjava3/parallel/ParallelTransformer.html | 247 + .../rxjava3/parallel/package-frame.html | 28 + .../rxjava3/parallel/package-summary.html | 193 + .../rxjava3/parallel/package-tree.html | 151 + .../rxjava3/plugins/RxJavaPlugins.html | 2185 ++ .../rxjava3/plugins/package-frame.html | 19 + .../rxjava3/plugins/package-summary.html | 152 + .../rxjava3/plugins/package-tree.html | 134 + .../rxjava3/processors/AsyncProcessor.html | 621 + .../rxjava3/processors/BehaviorProcessor.html | 729 + .../rxjava3/processors/FlowableProcessor.html | 427 + .../processors/MulticastProcessor.html | 757 + .../rxjava3/processors/PublishProcessor.html | 606 + .../rxjava3/processors/ReplayProcessor.html | 912 + .../rxjava3/processors/UnicastProcessor.html | 748 + .../rxjava3/processors/package-frame.html | 25 + .../rxjava3/processors/package-summary.html | 220 + .../rxjava3/processors/package-tree.html | 147 + .../SchedulerRunnableIntrospection.html | 240 + .../rxjava3/schedulers/Schedulers.html | 857 + .../rxjava3/schedulers/TestScheduler.html | 494 + .../reactivex/rxjava3/schedulers/Timed.html | 415 + .../rxjava3/schedulers/package-frame.html | 25 + .../rxjava3/schedulers/package-summary.html | 188 + .../rxjava3/schedulers/package-tree.html | 144 + .../rxjava3/subjects/AsyncSubject.html | 635 + .../rxjava3/subjects/BehaviorSubject.html | 707 + .../rxjava3/subjects/CompletableSubject.html | 502 + .../rxjava3/subjects/MaybeSubject.html | 605 + .../rxjava3/subjects/PublishSubject.html | 578 + .../rxjava3/subjects/ReplaySubject.html | 928 + .../rxjava3/subjects/SingleSubject.html | 552 + .../reactivex/rxjava3/subjects/Subject.html | 415 + .../rxjava3/subjects/UnicastSubject.html | 768 + .../rxjava3/subjects/package-frame.html | 27 + .../rxjava3/subjects/package-summary.html | 247 + .../rxjava3/subjects/package-tree.html | 161 + .../subscribers/DefaultSubscriber.html | 408 + .../subscribers/DisposableSubscriber.html | 461 + .../subscribers/ResourceSubscriber.html | 484 + .../rxjava3/subscribers/SafeSubscriber.html | 395 + .../subscribers/SerializedSubscriber.html | 426 + .../rxjava3/subscribers/TestSubscriber.html | 706 + .../rxjava3/subscribers/package-frame.html | 24 + .../rxjava3/subscribers/package-summary.html | 194 + .../rxjava3/subscribers/package-tree.html | 143 + 3.x/javadoc/3.1.8/overview-frame.html | 34 + 3.x/javadoc/3.1.8/overview-summary.html | 256 + 3.x/javadoc/3.1.8/overview-tree.html | 382 + 3.x/javadoc/3.1.8/package-list | 15 + 3.x/javadoc/3.1.8/script.js | 30 + 3.x/javadoc/3.1.8/serialized-form.html | 243 + 3.x/javadoc/3.1.8/stylesheet.css | 573 + 3.x/javadoc/allclasses-frame.html | 2 +- 3.x/javadoc/allclasses-noframe.html | 2 +- 3.x/javadoc/constant-values.html | 4 +- 3.x/javadoc/deprecated-list.html | 4 +- 3.x/javadoc/help-doc.html | 4 +- 3.x/javadoc/index-all.html | 4 +- 3.x/javadoc/index.html | 2 +- .../rxjava3/annotations/BackpressureKind.html | 4 +- .../annotations/BackpressureSupport.html | 4 +- .../reactivex/rxjava3/annotations/Beta.html | 4 +- .../rxjava3/annotations/CheckReturnValue.html | 4 +- .../rxjava3/annotations/Experimental.html | 4 +- .../rxjava3/annotations/NonNull.html | 4 +- .../rxjava3/annotations/Nullable.html | 4 +- .../rxjava3/annotations/SchedulerSupport.html | 4 +- .../rxjava3/annotations/package-frame.html | 2 +- .../rxjava3/annotations/package-summary.html | 4 +- .../rxjava3/annotations/package-tree.html | 12 +- .../core/BackpressureOverflowStrategy.html | 4 +- .../rxjava3/core/BackpressureStrategy.html | 4 +- .../reactivex/rxjava3/core/Completable.html | 4 +- .../rxjava3/core/CompletableConverter.html | 4 +- .../rxjava3/core/CompletableEmitter.html | 4 +- .../rxjava3/core/CompletableObserver.html | 4 +- .../rxjava3/core/CompletableOnSubscribe.html | 4 +- .../rxjava3/core/CompletableOperator.html | 4 +- .../rxjava3/core/CompletableSource.html | 4 +- .../rxjava3/core/CompletableTransformer.html | 4 +- .../io/reactivex/rxjava3/core/Emitter.html | 4 +- .../io/reactivex/rxjava3/core/Flowable.html | 4 +- .../rxjava3/core/FlowableConverter.html | 4 +- .../rxjava3/core/FlowableEmitter.html | 4 +- .../rxjava3/core/FlowableOnSubscribe.html | 4 +- .../rxjava3/core/FlowableOperator.html | 4 +- .../rxjava3/core/FlowableSubscriber.html | 4 +- .../rxjava3/core/FlowableTransformer.html | 4 +- .../io/reactivex/rxjava3/core/Maybe.html | 4 +- .../rxjava3/core/MaybeConverter.html | 4 +- .../reactivex/rxjava3/core/MaybeEmitter.html | 4 +- .../reactivex/rxjava3/core/MaybeObserver.html | 4 +- .../rxjava3/core/MaybeOnSubscribe.html | 4 +- .../reactivex/rxjava3/core/MaybeOperator.html | 4 +- .../reactivex/rxjava3/core/MaybeSource.html | 4 +- .../rxjava3/core/MaybeTransformer.html | 4 +- .../reactivex/rxjava3/core/Notification.html | 4 +- .../io/reactivex/rxjava3/core/Observable.html | 4 +- .../rxjava3/core/ObservableConverter.html | 4 +- .../rxjava3/core/ObservableEmitter.html | 4 +- .../rxjava3/core/ObservableOnSubscribe.html | 4 +- .../rxjava3/core/ObservableOperator.html | 4 +- .../rxjava3/core/ObservableSource.html | 4 +- .../rxjava3/core/ObservableTransformer.html | 4 +- .../io/reactivex/rxjava3/core/Observer.html | 4 +- .../rxjava3/core/Scheduler.Worker.html | 4 +- .../io/reactivex/rxjava3/core/Scheduler.html | 4 +- .../io/reactivex/rxjava3/core/Single.html | 4 +- .../rxjava3/core/SingleConverter.html | 4 +- .../reactivex/rxjava3/core/SingleEmitter.html | 4 +- .../rxjava3/core/SingleObserver.html | 4 +- .../rxjava3/core/SingleOnSubscribe.html | 4 +- .../rxjava3/core/SingleOperator.html | 4 +- .../reactivex/rxjava3/core/SingleSource.html | 4 +- .../rxjava3/core/SingleTransformer.html | 4 +- .../reactivex/rxjava3/core/package-frame.html | 2 +- .../rxjava3/core/package-summary.html | 4 +- .../reactivex/rxjava3/core/package-tree.html | 4 +- .../disposables/CompositeDisposable.html | 4 +- .../rxjava3/disposables/Disposable.html | 4 +- .../disposables/DisposableContainer.html | 4 +- .../rxjava3/disposables/SerialDisposable.html | 4 +- .../rxjava3/disposables/package-frame.html | 2 +- .../rxjava3/disposables/package-summary.html | 4 +- .../rxjava3/disposables/package-tree.html | 4 +- .../exceptions/CompositeException.html | 4 +- .../rxjava3/exceptions/Exceptions.html | 4 +- .../MissingBackpressureException.html | 4 +- .../OnErrorNotImplementedException.html | 4 +- .../ProtocolViolationException.html | 4 +- .../exceptions/QueueOverflowException.html | 4 +- .../exceptions/UndeliverableException.html | 4 +- .../rxjava3/exceptions/package-frame.html | 2 +- .../rxjava3/exceptions/package-summary.html | 4 +- .../rxjava3/exceptions/package-tree.html | 4 +- .../flowables/ConnectableFlowable.html | 4 +- .../rxjava3/flowables/GroupedFlowable.html | 4 +- .../rxjava3/flowables/package-frame.html | 2 +- .../rxjava3/flowables/package-summary.html | 4 +- .../rxjava3/flowables/package-tree.html | 4 +- .../reactivex/rxjava3/functions/Action.html | 4 +- .../rxjava3/functions/BiConsumer.html | 4 +- .../rxjava3/functions/BiFunction.html | 4 +- .../rxjava3/functions/BiPredicate.html | 4 +- .../rxjava3/functions/BooleanSupplier.html | 4 +- .../rxjava3/functions/Cancellable.html | 4 +- .../reactivex/rxjava3/functions/Consumer.html | 4 +- .../reactivex/rxjava3/functions/Function.html | 4 +- .../rxjava3/functions/Function3.html | 4 +- .../rxjava3/functions/Function4.html | 4 +- .../rxjava3/functions/Function5.html | 4 +- .../rxjava3/functions/Function6.html | 4 +- .../rxjava3/functions/Function7.html | 4 +- .../rxjava3/functions/Function8.html | 4 +- .../rxjava3/functions/Function9.html | 4 +- .../rxjava3/functions/IntFunction.html | 4 +- .../rxjava3/functions/LongConsumer.html | 4 +- .../rxjava3/functions/Predicate.html | 4 +- .../reactivex/rxjava3/functions/Supplier.html | 4 +- .../rxjava3/functions/package-frame.html | 2 +- .../rxjava3/functions/package-summary.html | 4 +- .../rxjava3/functions/package-tree.html | 4 +- .../observables/ConnectableObservable.html | 4 +- .../observables/GroupedObservable.html | 4 +- .../rxjava3/observables/package-frame.html | 2 +- .../rxjava3/observables/package-summary.html | 4 +- .../rxjava3/observables/package-tree.html | 4 +- .../rxjava3/observers/BaseTestConsumer.html | 4 +- .../rxjava3/observers/DefaultObserver.html | 4 +- .../DisposableCompletableObserver.html | 4 +- .../observers/DisposableMaybeObserver.html | 4 +- .../rxjava3/observers/DisposableObserver.html | 4 +- .../observers/DisposableSingleObserver.html | 4 +- .../LambdaConsumerIntrospection.html | 4 +- .../ResourceCompletableObserver.html | 4 +- .../observers/ResourceMaybeObserver.html | 4 +- .../rxjava3/observers/ResourceObserver.html | 4 +- .../observers/ResourceSingleObserver.html | 4 +- .../rxjava3/observers/SafeObserver.html | 4 +- .../rxjava3/observers/SerializedObserver.html | 4 +- .../rxjava3/observers/TestObserver.html | 4 +- .../rxjava3/observers/package-frame.html | 2 +- .../rxjava3/observers/package-summary.html | 4 +- .../rxjava3/observers/package-tree.html | 4 +- .../operators/ConditionalSubscriber.html | 4 +- .../rxjava3/operators/QueueDisposable.html | 4 +- .../rxjava3/operators/QueueFuseable.html | 4 +- .../rxjava3/operators/QueueSubscription.html | 4 +- .../rxjava3/operators/ScalarSupplier.html | 4 +- .../rxjava3/operators/SimplePlainQueue.html | 4 +- .../rxjava3/operators/SimpleQueue.html | 4 +- .../rxjava3/operators/SpscArrayQueue.html | 4 +- .../operators/SpscLinkedArrayQueue.html | 4 +- .../rxjava3/operators/package-frame.html | 2 +- .../rxjava3/operators/package-summary.html | 4 +- .../rxjava3/operators/package-tree.html | 4 +- .../parallel/ParallelFailureHandling.html | 4 +- .../rxjava3/parallel/ParallelFlowable.html | 4 +- .../parallel/ParallelFlowableConverter.html | 4 +- .../rxjava3/parallel/ParallelTransformer.html | 4 +- .../rxjava3/parallel/package-frame.html | 2 +- .../rxjava3/parallel/package-summary.html | 4 +- .../rxjava3/parallel/package-tree.html | 4 +- .../rxjava3/plugins/RxJavaPlugins.html | 4 +- .../rxjava3/plugins/package-frame.html | 2 +- .../rxjava3/plugins/package-summary.html | 4 +- .../rxjava3/plugins/package-tree.html | 4 +- .../rxjava3/processors/AsyncProcessor.html | 4 +- .../rxjava3/processors/BehaviorProcessor.html | 4 +- .../rxjava3/processors/FlowableProcessor.html | 4 +- .../processors/MulticastProcessor.html | 4 +- .../rxjava3/processors/PublishProcessor.html | 4 +- .../rxjava3/processors/ReplayProcessor.html | 4 +- .../rxjava3/processors/UnicastProcessor.html | 4 +- .../rxjava3/processors/package-frame.html | 2 +- .../rxjava3/processors/package-summary.html | 4 +- .../rxjava3/processors/package-tree.html | 4 +- .../SchedulerRunnableIntrospection.html | 4 +- .../rxjava3/schedulers/Schedulers.html | 4 +- .../rxjava3/schedulers/TestScheduler.html | 4 +- .../reactivex/rxjava3/schedulers/Timed.html | 4 +- .../rxjava3/schedulers/package-frame.html | 2 +- .../rxjava3/schedulers/package-summary.html | 4 +- .../rxjava3/schedulers/package-tree.html | 4 +- .../rxjava3/subjects/AsyncSubject.html | 4 +- .../rxjava3/subjects/BehaviorSubject.html | 4 +- .../rxjava3/subjects/CompletableSubject.html | 4 +- .../rxjava3/subjects/MaybeSubject.html | 4 +- .../rxjava3/subjects/PublishSubject.html | 4 +- .../rxjava3/subjects/ReplaySubject.html | 4 +- .../rxjava3/subjects/SingleSubject.html | 4 +- .../reactivex/rxjava3/subjects/Subject.html | 4 +- .../rxjava3/subjects/UnicastSubject.html | 4 +- .../rxjava3/subjects/package-frame.html | 2 +- .../rxjava3/subjects/package-summary.html | 4 +- .../rxjava3/subjects/package-tree.html | 4 +- .../subscribers/DefaultSubscriber.html | 4 +- .../subscribers/DisposableSubscriber.html | 4 +- .../subscribers/ResourceSubscriber.html | 4 +- .../rxjava3/subscribers/SafeSubscriber.html | 4 +- .../subscribers/SerializedSubscriber.html | 4 +- .../rxjava3/subscribers/TestSubscriber.html | 4 +- .../rxjava3/subscribers/package-frame.html | 2 +- .../rxjava3/subscribers/package-summary.html | 4 +- .../rxjava3/subscribers/package-tree.html | 4 +- 3.x/javadoc/overview-frame.html | 2 +- 3.x/javadoc/overview-summary.html | 6 +- 3.x/javadoc/overview-tree.html | 14 +- 3.x/javadoc/serialized-form.html | 4 +- 397 files changed, 152866 insertions(+), 385 deletions(-) create mode 100644 3.x/javadoc/3.1.8/allclasses-frame.html create mode 100644 3.x/javadoc/3.1.8/allclasses-noframe.html create mode 100644 3.x/javadoc/3.1.8/constant-values.html create mode 100644 3.x/javadoc/3.1.8/deprecated-list.html create mode 100644 3.x/javadoc/3.1.8/help-doc.html create mode 100644 3.x/javadoc/3.1.8/index-all.html create mode 100644 3.x/javadoc/3.1.8/index.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/BackpressureKind.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/BackpressureSupport.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/Beta.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/CheckReturnValue.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/Experimental.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/NonNull.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/Nullable.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/SchedulerSupport.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/package-frame.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/package-summary.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/package-tree.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/BackpressureOverflowStrategy.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/BackpressureStrategy.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Completable.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableConverter.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableEmitter.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableObserver.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableOnSubscribe.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableOperator.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableSource.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableTransformer.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Emitter.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Flowable.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableConverter.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableEmitter.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableOnSubscribe.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableOperator.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableSubscriber.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableTransformer.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Maybe.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeConverter.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeEmitter.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeObserver.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeOnSubscribe.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeOperator.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeSource.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeTransformer.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Notification.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Observable.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableConverter.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableEmitter.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableOnSubscribe.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableOperator.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableSource.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableTransformer.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Observer.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Scheduler.Worker.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Scheduler.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Single.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleConverter.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleEmitter.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleObserver.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleOnSubscribe.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleOperator.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleSource.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleTransformer.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/package-frame.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/package-summary.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/package-tree.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/CompositeDisposable.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/Disposable.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/DisposableContainer.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/SerialDisposable.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/package-frame.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/package-summary.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/package-tree.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/CompositeException.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/Exceptions.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/MissingBackpressureException.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/OnErrorNotImplementedException.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/ProtocolViolationException.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/QueueOverflowException.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/UndeliverableException.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/package-frame.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/package-summary.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/package-tree.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/ConnectableFlowable.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/GroupedFlowable.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/package-frame.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/package-summary.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/package-tree.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Action.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BiConsumer.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BiFunction.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BiPredicate.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BooleanSupplier.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Cancellable.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Consumer.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function3.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function4.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function5.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function6.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function7.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function8.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function9.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/IntFunction.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/LongConsumer.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Predicate.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Supplier.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/package-frame.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/package-summary.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/package-tree.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/ConnectableObservable.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/GroupedObservable.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/package-frame.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/package-summary.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/package-tree.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/BaseTestConsumer.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DefaultObserver.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableCompletableObserver.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableMaybeObserver.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableObserver.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableSingleObserver.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/LambdaConsumerIntrospection.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceCompletableObserver.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceMaybeObserver.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceObserver.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceSingleObserver.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/SafeObserver.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/SerializedObserver.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/TestObserver.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/package-frame.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/package-summary.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/package-tree.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/ConditionalSubscriber.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/QueueDisposable.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/QueueFuseable.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/QueueSubscription.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/ScalarSupplier.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SimplePlainQueue.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SimpleQueue.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SpscArrayQueue.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SpscLinkedArrayQueue.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/package-frame.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/package-summary.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/package-tree.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelFailureHandling.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelFlowable.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelFlowableConverter.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelTransformer.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/package-frame.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/package-summary.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/package-tree.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/RxJavaPlugins.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/package-frame.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/package-summary.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/package-tree.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/AsyncProcessor.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/BehaviorProcessor.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/FlowableProcessor.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/MulticastProcessor.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/PublishProcessor.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/ReplayProcessor.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/UnicastProcessor.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/package-frame.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/package-summary.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/package-tree.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/SchedulerRunnableIntrospection.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/Schedulers.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/TestScheduler.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/Timed.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/package-frame.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/package-summary.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/package-tree.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/AsyncSubject.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/BehaviorSubject.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/CompletableSubject.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/MaybeSubject.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/PublishSubject.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/ReplaySubject.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/SingleSubject.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/Subject.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/UnicastSubject.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/package-frame.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/package-summary.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/package-tree.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/DefaultSubscriber.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/DisposableSubscriber.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/ResourceSubscriber.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/SafeSubscriber.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/SerializedSubscriber.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/TestSubscriber.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/package-frame.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/package-summary.html create mode 100644 3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/package-tree.html create mode 100644 3.x/javadoc/3.1.8/overview-frame.html create mode 100644 3.x/javadoc/3.1.8/overview-summary.html create mode 100644 3.x/javadoc/3.1.8/overview-tree.html create mode 100644 3.x/javadoc/3.1.8/package-list create mode 100644 3.x/javadoc/3.1.8/script.js create mode 100644 3.x/javadoc/3.1.8/serialized-form.html create mode 100644 3.x/javadoc/3.1.8/stylesheet.css diff --git a/3.x/javadoc/3.1.8/allclasses-frame.html b/3.x/javadoc/3.1.8/allclasses-frame.html new file mode 100644 index 0000000000..3f150b1dd8 --- /dev/null +++ b/3.x/javadoc/3.1.8/allclasses-frame.html @@ -0,0 +1,158 @@ + + + + + +All Classes (RxJava Javadoc 3.1.8) + + + + +

All Classes

+
+ +
+ + diff --git a/3.x/javadoc/3.1.8/allclasses-noframe.html b/3.x/javadoc/3.1.8/allclasses-noframe.html new file mode 100644 index 0000000000..7ccacd19f7 --- /dev/null +++ b/3.x/javadoc/3.1.8/allclasses-noframe.html @@ -0,0 +1,158 @@ + + + + + +All Classes (RxJava Javadoc 3.1.8) + + + + +

All Classes

+
+ +
+ + diff --git a/3.x/javadoc/3.1.8/constant-values.html b/3.x/javadoc/3.1.8/constant-values.html new file mode 100644 index 0000000000..6805e4c55b --- /dev/null +++ b/3.x/javadoc/3.1.8/constant-values.html @@ -0,0 +1,262 @@ + + + + + +Constant Field Values (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Constant Field Values

+

Contents

+ +
+
+ + +

io.reactivex.*

+ + + +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/deprecated-list.html b/3.x/javadoc/3.1.8/deprecated-list.html new file mode 100644 index 0000000000..3c0c37f87b --- /dev/null +++ b/3.x/javadoc/3.1.8/deprecated-list.html @@ -0,0 +1,121 @@ + + + + + +Deprecated List (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Deprecated API

+

Contents

+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/help-doc.html b/3.x/javadoc/3.1.8/help-doc.html new file mode 100644 index 0000000000..f18de78d08 --- /dev/null +++ b/3.x/javadoc/3.1.8/help-doc.html @@ -0,0 +1,222 @@ + + + + + +API Help (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

How This API Document Is Organized

+
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
+
+
+ +This help file applies to API documentation generated using the standard doclet.
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/index-all.html b/3.x/javadoc/3.1.8/index-all.html new file mode 100644 index 0000000000..6c9ede1e6a --- /dev/null +++ b/3.x/javadoc/3.1.8/index-all.html @@ -0,0 +1,11734 @@ + + + + + +Index (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
A B C D E F G H I J L M N O P Q R S T U V W Z  + + +

A

+
+
accept(T1, T2) - Method in interface io.reactivex.rxjava3.functions.BiConsumer
+
+
Performs an operation on the given values.
+
+
accept(T) - Method in interface io.reactivex.rxjava3.functions.Consumer
+
+
Consume the given value.
+
+
accept(long) - Method in interface io.reactivex.rxjava3.functions.LongConsumer
+
+
Consume a primitive long input.
+
+
Action - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface similar to Runnable but allows throwing a checked exception.
+
+
add(Disposable) - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable
+
+
Adds a Disposable to this container or disposes it if the + container has been disposed.
+
+
add(Disposable) - Method in interface io.reactivex.rxjava3.disposables.DisposableContainer
+
+
Adds a disposable to this container or disposes it if the + container has been disposed.
+
+
add(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceCompletableObserver
+
+
Adds a resource to this ResourceCompletableObserver.
+
+
add(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceMaybeObserver
+
+
Adds a resource to this ResourceMaybeObserver.
+
+
add(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceObserver
+
+
Adds a resource to this ResourceObserver.
+
+
add(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceSingleObserver
+
+
Adds a resource to this ResourceSingleObserver.
+
+
add(Disposable) - Method in class io.reactivex.rxjava3.subscribers.ResourceSubscriber
+
+
Adds a resource to this ResourceSubscriber.
+
+
addAll(Disposable...) - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable
+
+
Atomically adds the given array of Disposables to the container or + disposes them all if the container has been disposed.
+
+
advanceTimeBy(long, TimeUnit) - Method in class io.reactivex.rxjava3.schedulers.TestScheduler
+
+
Moves the Scheduler's clock forward by a specified amount of time.
+
+
advanceTimeTo(long, TimeUnit) - Method in class io.reactivex.rxjava3.schedulers.TestScheduler
+
+
Moves the Scheduler's clock to a particular moment in time.
+
+
all(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a Boolean that indicates whether all of the items emitted by the current + Flowable satisfy a condition.
+
+
all(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a Boolean that indicates whether all of the items emitted by the current + Observable satisfy a condition.
+
+
amb(Iterable<? extends CompletableSource>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which terminates as soon as one of the source Completables in the Iterable sequence + terminates (normally or with an error) and disposes all other Completables.
+
+
amb(Iterable<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Mirrors the one Publisher in an Iterable of several Publishers that first either emits an item or sends + a termination notification.
+
+
amb(Iterable<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Runs multiple MaybeSources provided by an Iterable sequence and + signals the events of the first one that signals (disposing the rest).
+
+
amb(Iterable<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Mirrors the one ObservableSource in an Iterable of several ObservableSources that first either emits an item or sends + a termination notification.
+
+
amb(Iterable<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Runs multiple SingleSources and signals the events of the first one that signals (disposing + the rest).
+
+
ambArray(CompletableSource...) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which terminates as soon as one of the source Completables + terminates (normally or with an error) and disposes all other Completables.
+
+
ambArray(Publisher<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Mirrors the one Publisher in an array of several Publishers that first either emits an item or sends + a termination notification.
+
+
ambArray(MaybeSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Runs multiple MaybeSources and signals the events of the first one that signals (disposing + the rest).
+
+
ambArray(ObservableSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Mirrors the one ObservableSource in an array of several ObservableSources that first either emits an item or sends + a termination notification.
+
+
ambArray(SingleSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Runs multiple SingleSources and signals the events of the first one that signals (disposing + the rest).
+
+
ambWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that emits the a terminated event of either this Completable + or the other CompletableSource, whichever fires first.
+
+
ambWith(Publisher<? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Mirrors the Publisher (current or provided) that first either emits an item or sends a termination + notification.
+
+
ambWith(MaybeSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Mirrors the MaybeSource (current or provided) that first signals an event.
+
+
ambWith(ObservableSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Mirrors the current Observable or the other ObservableSource provided of which the first either emits an item or sends a termination + notification.
+
+
ambWith(SingleSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Signals the event of this or the other SingleSource whichever signals first.
+
+
andThen(ObservableSource<T>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns an Observable which will subscribe to this Completable and once that is completed then + will subscribe to the next ObservableSource.
+
+
andThen(Publisher<T>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Flowable which will subscribe to this Completable and once that is completed then + will subscribe to the next Publisher.
+
+
andThen(SingleSource<T>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Single which will subscribe to this Completable and once that is completed then + will subscribe to the next SingleSource.
+
+
andThen(MaybeSource<T>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Maybe which will subscribe to this Completable and once that is completed then + will subscribe to the next MaybeSource.
+
+
andThen(CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that first runs this Completable + and then the other CompletableSource.
+
+
any(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits true if any item emitted by the current Flowable satisfies a + specified condition, otherwise false.
+
+
any(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits true if any item emitted by the current Observable satisfies a + specified condition, otherwise false.
+
+
ANY - Static variable in interface io.reactivex.rxjava3.operators.QueueFuseable
+
+
Request any of the QueueFuseable.SYNC or QueueFuseable.ASYNC modes.
+
+
apply(Completable) - Method in interface io.reactivex.rxjava3.core.CompletableConverter
+
+
Applies a function to the upstream Completable and returns a converted value of type R.
+
+
apply(CompletableObserver) - Method in interface io.reactivex.rxjava3.core.CompletableOperator
+
+
Applies a function to the child CompletableObserver and returns a new parent CompletableObserver.
+
+
apply(Completable) - Method in interface io.reactivex.rxjava3.core.CompletableTransformer
+
+
Applies a function to the upstream Completable and returns a CompletableSource.
+
+
apply(Flowable<T>) - Method in interface io.reactivex.rxjava3.core.FlowableConverter
+
+
Applies a function to the upstream Flowable and returns a converted value of type R.
+
+
apply(Subscriber<? super Downstream>) - Method in interface io.reactivex.rxjava3.core.FlowableOperator
+
+
Applies a function to the child Subscriber and returns a new parent Subscriber.
+
+
apply(Flowable<Upstream>) - Method in interface io.reactivex.rxjava3.core.FlowableTransformer
+
+
Applies a function to the upstream Flowable and returns a Publisher with + optionally different element type.
+
+
apply(Maybe<T>) - Method in interface io.reactivex.rxjava3.core.MaybeConverter
+
+
Applies a function to the upstream Maybe and returns a converted value of type R.
+
+
apply(MaybeObserver<? super Downstream>) - Method in interface io.reactivex.rxjava3.core.MaybeOperator
+
+
Applies a function to the child MaybeObserver and returns a new parent MaybeObserver.
+
+
apply(Maybe<Upstream>) - Method in interface io.reactivex.rxjava3.core.MaybeTransformer
+
+
Applies a function to the upstream Maybe and returns a MaybeSource with + optionally different element type.
+
+
apply(Observable<T>) - Method in interface io.reactivex.rxjava3.core.ObservableConverter
+
+
Applies a function to the upstream Observable and returns a converted value of type R.
+
+
apply(Observer<? super Downstream>) - Method in interface io.reactivex.rxjava3.core.ObservableOperator
+
+
Applies a function to the child Observer and returns a new parent Observer.
+
+
apply(Observable<Upstream>) - Method in interface io.reactivex.rxjava3.core.ObservableTransformer
+
+
Applies a function to the upstream Observable and returns an ObservableSource with + optionally different element type.
+
+
apply(Single<T>) - Method in interface io.reactivex.rxjava3.core.SingleConverter
+
+
Applies a function to the upstream Single and returns a converted value of type R.
+
+
apply(SingleObserver<? super Downstream>) - Method in interface io.reactivex.rxjava3.core.SingleOperator
+
+
Applies a function to the child SingleObserver and returns a new parent SingleObserver.
+
+
apply(Single<Upstream>) - Method in interface io.reactivex.rxjava3.core.SingleTransformer
+
+
Applies a function to the upstream Single and returns a SingleSource with + optionally different element type.
+
+
apply(T1, T2) - Method in interface io.reactivex.rxjava3.functions.BiFunction
+
+
Calculate a value based on the input values.
+
+
apply(T) - Method in interface io.reactivex.rxjava3.functions.Function
+
+
Apply some calculation to the input value and return some other value.
+
+
apply(T1, T2, T3) - Method in interface io.reactivex.rxjava3.functions.Function3
+
+
Calculate a value based on the input values.
+
+
apply(T1, T2, T3, T4) - Method in interface io.reactivex.rxjava3.functions.Function4
+
+
Calculate a value based on the input values.
+
+
apply(T1, T2, T3, T4, T5) - Method in interface io.reactivex.rxjava3.functions.Function5
+
+
Calculate a value based on the input values.
+
+
apply(T1, T2, T3, T4, T5, T6) - Method in interface io.reactivex.rxjava3.functions.Function6
+
+
Calculate a value based on the input values.
+
+
apply(T1, T2, T3, T4, T5, T6, T7) - Method in interface io.reactivex.rxjava3.functions.Function7
+
+
Calculate a value based on the input values.
+
+
apply(T1, T2, T3, T4, T5, T6, T7, T8) - Method in interface io.reactivex.rxjava3.functions.Function8
+
+
Calculate a value based on the input values.
+
+
apply(T1, T2, T3, T4, T5, T6, T7, T8, T9) - Method in interface io.reactivex.rxjava3.functions.Function9
+
+
Calculate a value based on the input values.
+
+
apply(int) - Method in interface io.reactivex.rxjava3.functions.IntFunction
+
+
Calculates a value based on a primitive integer input.
+
+
apply(Long, Throwable) - Method in enum io.reactivex.rxjava3.parallel.ParallelFailureHandling
+
 
+
apply(ParallelFlowable<T>) - Method in interface io.reactivex.rxjava3.parallel.ParallelFlowableConverter
+
+
Applies a function to the upstream ParallelFlowable and returns a converted value of type R.
+
+
apply(ParallelFlowable<Upstream>) - Method in interface io.reactivex.rxjava3.parallel.ParallelTransformer
+
+
Applies a function to the upstream ParallelFlowable and returns a ParallelFlowable with + optionally different element type.
+
+
assertComplete() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Assert that this TestObserver/TestSubscriber received exactly one onComplete event.
+
+
assertEmpty() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Assert that the TestObserver/TestSubscriber has received a + Disposable/Subscription + via onSubscribe but no other events.
+
+
assertError(Throwable) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Assert that this TestObserver/TestSubscriber received exactly the specified onError event value.
+
+
assertError(Class<? extends Throwable>) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Asserts that this TestObserver/TestSubscriber received exactly one onError event which is an + instance of the specified errorClass Class.
+
+
assertError(Predicate<Throwable>) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Asserts that this TestObserver/TestSubscriber received exactly one onError event for which + the provided predicate returns true.
+
+
assertFailure(Class<? extends Throwable>, T...) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Assert that the upstream signaled the specified values in order + and then failed with a specific class or subclass of Throwable.
+
+
assertNoErrors() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Assert that this TestObserver/TestSubscriber has not received an onError event.
+
+
assertNotComplete() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Assert that this TestObserver/TestSubscriber has not received an onComplete event.
+
+
assertNoValues() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Assert that this TestObserver/TestSubscriber has not received any onNext events.
+
+
assertResult(T...) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Assert that the upstream signaled the specified values in order and + completed normally.
+
+
assertSubscribed() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Assert that the onSubscribe method was called exactly once.
+
+
assertSubscribed() - Method in class io.reactivex.rxjava3.observers.TestObserver
+
+
Assert that the TestObserver.onSubscribe(Disposable) method was called exactly once.
+
+
assertSubscribed() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
+
Assert that the TestSubscriber.onSubscribe(Subscription) method was called exactly once.
+
+
assertValue(T) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Assert that this TestObserver/TestSubscriber received exactly one onNext value which is equal to + the given value with respect to Objects.equals(Object, Object).
+
+
assertValue(Predicate<T>) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Asserts that this TestObserver/TestSubscriber received exactly one onNext value for which + the provided predicate returns true.
+
+
assertValueAt(int, T) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Asserts that this TestObserver/TestSubscriber received an onNext value at the given index + which is equal to the given value with respect to null-safe Objects.equals(Object, Object).
+
+
assertValueAt(int, Predicate<T>) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Asserts that this TestObserver/TestSubscriber received an onNext value at the given index + for the provided predicate returns true.
+
+
assertValueCount(int) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Assert that this TestObserver/TestSubscriber received the specified number onNext events.
+
+
assertValues(T...) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Assert that the TestObserver/TestSubscriber received only the specified values in the specified order.
+
+
assertValueSequence(Iterable<? extends T>) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Assert that the TestObserver/TestSubscriber received only the specified sequence of values in the same order.
+
+
assertValuesOnly(T...) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Assert that the TestObserver/TestSubscriber received only the specified values in the specified order without terminating.
+
+
ASYNC - Static variable in interface io.reactivex.rxjava3.operators.QueueFuseable
+
+
Request an asynchronous fusion mode and can be returned by QueueFuseable.requestFusion(int) + for an accepted mode.
+
+
AsyncProcessor<T> - Class in io.reactivex.rxjava3.processors
+
+
Processor that emits the very last value followed by a completion event or the received error + to Subscribers.
+
+
AsyncSubject<T> - Class in io.reactivex.rxjava3.subjects
+
+
A Subject that emits the very last value followed by a completion event or the received error to Observers.
+
+
autoConnect() - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable
+
+
Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable + when the first Subscriber subscribes.
+
+
autoConnect(int) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable
+
+
Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable + when the specified number of Subscribers subscribe to it.
+
+
autoConnect(int, Consumer<? super Disposable>) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable
+
+
Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable + when the specified number of Subscribers subscribe to it and calls the + specified callback with the Disposable associated with the established connection.
+
+
autoConnect() - Method in class io.reactivex.rxjava3.observables.ConnectableObservable
+
+
Returns an Observable that automatically connects (at most once) to this ConnectableObservable + when the first Observer subscribes.
+
+
autoConnect(int) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable
+
+
Returns an Observable that automatically connects (at most once) to this ConnectableObservable + when the specified number of Observers subscribe to it.
+
+
autoConnect(int, Consumer<? super Disposable>) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable
+
+
Returns an Observable that automatically connects (at most once) to this ConnectableObservable + when the specified number of Observers subscribe to it and calls the + specified callback with the Disposable associated with the established connection.
+
+
await() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Awaits until this TestObserver/TestSubscriber receives an onError or onComplete events.
+
+
await(long, TimeUnit) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Awaits the specified amount of time or until this TestObserver/TestSubscriber + receives an onError or onComplete events, whichever happens first.
+
+
awaitCount(int) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Await until the TestObserver/TestSubscriber receives the given + number of items or terminates by sleeping 10 milliseconds at a time + up to 5000 milliseconds of timeout.
+
+
awaitDone(long, TimeUnit) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Awaits until the internal latch is counted down.
+
+
+ + + +

B

+
+
BackpressureKind - Enum in io.reactivex.rxjava3.annotations
+
+
Enumeration for various kinds of backpressure support.
+
+
BackpressureOverflowStrategy - Enum in io.reactivex.rxjava3.core
+
+
Options to deal with buffer overflow when using onBackpressureBuffer.
+
+
BackpressureStrategy - Enum in io.reactivex.rxjava3.core
+
+
Represents the options for applying backpressure to a source sequence.
+
+
BackpressureSupport - Annotation Type in io.reactivex.rxjava3.annotations
+
+
Indicates the backpressure support kind of the associated operator or class.
+
+
BaseTestConsumer<T,U extends BaseTestConsumer<T,U>> - Class in io.reactivex.rxjava3.observers
+
+
Base class with shared infrastructure to support + TestSubscriber and TestObserver.
+
+
BaseTestConsumer() - Constructor for class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Constructs a BaseTestConsumer with CountDownLatch set to 1.
+
+
BehaviorProcessor<T> - Class in io.reactivex.rxjava3.processors
+
+
Processor that emits the most recent item it has observed and all subsequent observed items to each subscribed + Subscriber.
+
+
BehaviorSubject<T> - Class in io.reactivex.rxjava3.subjects
+
+
Subject that emits the most recent item it has observed and all subsequent observed items to each subscribed + Observer.
+
+
Beta - Annotation Type in io.reactivex.rxjava3.annotations
+
+
Indicates the feature is in beta state: it will be most likely stay but + the signature may change between versions without warning.
+
+
BiConsumer<T1,T2> - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that accepts two values (of possibly different types).
+
+
BiFunction<T1,T2,R> - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that computes a value based on multiple input values.
+
+
BiPredicate<T1,T2> - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that returns true or false for the given input values.
+
+
blockingAwait() - Method in class io.reactivex.rxjava3.core.Completable
+
+
Subscribes to and awaits the termination of this Completable instance in a blocking manner and + rethrows any exception emitted.
+
+
blockingAwait(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Subscribes to and awaits the termination of this Completable instance in a blocking manner + with a specific timeout and rethrows any exception emitted within the timeout window.
+
+
blockingFirst() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns the first item emitted by this Flowable, or throws + NoSuchElementException if it emits no items.
+
+
blockingFirst(T) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns the first item emitted by this Flowable, or a default value if it emits no + items.
+
+
blockingFirst() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns the first item emitted by the current Observable, or throws + NoSuchElementException if it emits no items.
+
+
blockingFirst(T) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns the first item emitted by the current Observable, or a default value if it emits no + items.
+
+
blockingForEach(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Consumes the current Flowable in a blocking fashion and invokes the given + Consumer with each upstream item on the current thread until the + upstream terminates.
+
+
blockingForEach(Consumer<? super T>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Consumes the current Flowable in a blocking fashion and invokes the given + Consumer with each upstream item on the current thread until the + upstream terminates.
+
+
blockingForEach(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Consumes the current Observable in a blocking fashion and invokes the given + Consumer with each upstream item on the current thread until the + upstream terminates.
+
+
blockingForEach(Consumer<? super T>, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Consumes the current Observable in a blocking fashion and invokes the given + Consumer with each upstream item on the current thread until the + upstream terminates.
+
+
blockingGet() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Waits in a blocking fashion until the current Maybe signals a success value (which is returned), + null if completed or an exception (which is propagated).
+
+
blockingGet(T) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Waits in a blocking fashion until the current Maybe signals a success value (which is returned), + defaultValue if completed or an exception (which is propagated).
+
+
blockingGet() - Method in class io.reactivex.rxjava3.core.Single
+
+
Waits in a blocking fashion until the current Single signals a success value (which is returned) or + an exception (which is propagated).
+
+
blockingIterable() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts this Flowable into an Iterable.
+
+
blockingIterable(int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts this Flowable into an Iterable.
+
+
blockingIterable() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Exposes the current Observable as an Iterable which, when iterated, + subscribes to the current Observable and blocks + until the current Observable emits items or terminates.
+
+
blockingIterable(int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Exposes the current Observable as an Iterable which, when iterated, + subscribes to the current Observable and blocks + until the current Observable emits items or terminates.
+
+
blockingLast() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns the last item emitted by this Flowable, or throws + NoSuchElementException if this Flowable emits no items.
+
+
blockingLast(T) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns the last item emitted by this Flowable, or a default value if it emits no + items.
+
+
blockingLast() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns the last item emitted by the current Observable, or throws + NoSuchElementException if the current Observable emits no items.
+
+
blockingLast(T) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns the last item emitted by the current Observable, or a default value if it emits no + items.
+
+
blockingLatest() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns an Iterable that returns the latest item emitted by this Flowable, + waiting if necessary for one to become available.
+
+
blockingLatest() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Iterable that returns the latest item emitted by the current Observable, + waiting if necessary for one to become available.
+
+
blockingMostRecent(T) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns an Iterable that always returns the item most recently emitted by this + Flowable.
+
+
blockingMostRecent(T) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Iterable that always returns the item most recently emitted by the current + Observable.
+
+
blockingNext() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns an Iterable that blocks until this Flowable emits another item, then + returns that item.
+
+
blockingNext() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Iterable that blocks until the current Observable emits another item, then + returns that item.
+
+
blockingSingle() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
If this Flowable completes after emitting a single item, return that item, otherwise + throw a NoSuchElementException.
+
+
blockingSingle(T) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
If this Flowable completes after emitting a single item, return that item; if it emits + more than one item, throw an IllegalArgumentException; if it emits no items, return a default + value.
+
+
blockingSingle() - Method in class io.reactivex.rxjava3.core.Observable
+
+
If the current Observable completes after emitting a single item, return that item, otherwise + throw a NoSuchElementException.
+
+
blockingSingle(T) - Method in class io.reactivex.rxjava3.core.Observable
+
+
If the current Observable completes after emitting a single item, return that item; if it emits + more than one item, throw an IllegalArgumentException; if it emits no items, return a default + value.
+
+
blockingStream() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Creates a sequential Stream to consume or process this Flowable in a blocking manner via + the Java Stream API.
+
+
blockingStream(int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Creates a sequential Stream to consume or process this Flowable in a blocking manner via + the Java Stream API.
+
+
blockingStream() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Creates a sequential Stream to consume or process the current Observable in a blocking manner via + the Java Stream API.
+
+
blockingStream(int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Creates a sequential Stream to consume or process the current Observable in a blocking manner via + the Java Stream API.
+
+
blockingSubscribe() - Method in class io.reactivex.rxjava3.core.Completable
+
+
Subscribes to the current Completable and blocks the current thread until it terminates.
+
+
blockingSubscribe(Action) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Subscribes to the current Completable and calls given onComplete callback on the current thread + when it completes normally.
+
+
blockingSubscribe(Action, Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Subscribes to the current Completable and calls the appropriate callback on the current thread + when it terminates.
+
+
blockingSubscribe(CompletableObserver) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Subscribes to the current Completable and calls the appropriate CompletableObserver method on the current thread.
+
+
blockingSubscribe() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Runs the current Flowable to a terminal event, ignoring any values and rethrowing any exception.
+
+
blockingSubscribe(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the source and calls the given callbacks on the current thread.
+
+
blockingSubscribe(Consumer<? super T>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the source and calls the given callbacks on the current thread.
+
+
blockingSubscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the source and calls the given callbacks on the current thread.
+
+
blockingSubscribe(Consumer<? super T>, Consumer<? super Throwable>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the source and calls the given callbacks on the current thread.
+
+
blockingSubscribe(Consumer<? super T>, Consumer<? super Throwable>, Action) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the source and calls the given callbacks on the current thread.
+
+
blockingSubscribe(Consumer<? super T>, Consumer<? super Throwable>, Action, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the source and calls the given callbacks on the current thread.
+
+
blockingSubscribe(Subscriber<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the source and calls the Subscriber methods on the current thread.
+
+
blockingSubscribe() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Subscribes to the current Maybe and blocks the current thread until it terminates.
+
+
blockingSubscribe(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Subscribes to the current Maybe and calls given onSuccess callback on the current thread + when it completes normally.
+
+
blockingSubscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Subscribes to the current Maybe and calls the appropriate callback on the current thread + when it terminates.
+
+
blockingSubscribe(Consumer<? super T>, Consumer<? super Throwable>, Action) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Subscribes to the current Maybe and calls the appropriate callback on the current thread + when it terminates.
+
+
blockingSubscribe(MaybeObserver<? super T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Subscribes to the current Maybe and calls the appropriate MaybeObserver method on the current thread.
+
+
blockingSubscribe() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Runs the current Observable to a terminal event, ignoring any values and rethrowing any exception.
+
+
blockingSubscribe(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Subscribes to the source and calls the given callbacks on the current thread.
+
+
blockingSubscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Subscribes to the source and calls the given callbacks on the current thread.
+
+
blockingSubscribe(Consumer<? super T>, Consumer<? super Throwable>, Action) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Subscribes to the source and calls the given callbacks on the current thread.
+
+
blockingSubscribe(Observer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Subscribes to the source and calls the Observer methods on the current thread.
+
+
blockingSubscribe() - Method in class io.reactivex.rxjava3.core.Single
+
+
Subscribes to the current Single and blocks the current thread until it terminates.
+
+
blockingSubscribe(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Subscribes to the current Single and calls given onSuccess callback on the current thread + when it completes normally.
+
+
blockingSubscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Subscribes to the current Single and calls the appropriate callback on the current thread + when it terminates.
+
+
blockingSubscribe(SingleObserver<? super T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Subscribes to the current Single and calls the appropriate SingleObserver method on the current thread.
+
+
BooleanSupplier - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that returns a boolean value.
+
+
BOUNDARY - Static variable in interface io.reactivex.rxjava3.operators.QueueFuseable
+
+
Used in binary or combination with the other constants as an input to QueueFuseable.requestFusion(int) + indicating that the SimpleQueue.poll() will be called behind an asynchronous boundary and thus + may change the non-trivial computation locations attached to the SimpleQueue.poll() chain of + fused operators.
+
+
buffer(int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits buffers of items it collects from the current Flowable.
+
+
buffer(int, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits buffers of items it collects from the current Flowable.
+
+
buffer(int, int, Supplier<U>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits buffers of items it collects from the current Flowable.
+
+
buffer(int, Supplier<U>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits buffers of items it collects from the current Flowable.
+
+
buffer(long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits buffers of items it collects from the current Flowable.
+
+
buffer(long, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits buffers of items it collects from the current Flowable.
+
+
buffer(long, long, TimeUnit, Scheduler, Supplier<U>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits buffers of items it collects from the current Flowable.
+
+
buffer(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits buffers of items it collects from the current Flowable.
+
+
buffer(long, TimeUnit, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits buffers of items it collects from the current Flowable.
+
+
buffer(long, TimeUnit, Scheduler, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits buffers of items it collects from the current Flowable.
+
+
buffer(long, TimeUnit, Scheduler, int, Supplier<U>, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits buffers of items it collects from the current Flowable.
+
+
buffer(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits buffers of items it collects from the current Flowable.
+
+
buffer(Publisher<? extends TOpening>, Function<? super TOpening, ? extends Publisher<? extends TClosing>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits buffers of items it collects from the current Flowable.
+
+
buffer(Publisher<? extends TOpening>, Function<? super TOpening, ? extends Publisher<? extends TClosing>>, Supplier<U>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits buffers of items it collects from the current Flowable.
+
+
buffer(Publisher<B>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits non-overlapping buffered items from the current Flowable each time the + specified boundary Publisher emits an item.
+
+
buffer(Publisher<B>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits non-overlapping buffered items from the current Flowable each time the + specified boundary Publisher emits an item.
+
+
buffer(Publisher<B>, Supplier<U>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits non-overlapping buffered items from the current Flowable each time the + specified boundary Publisher emits an item.
+
+
buffer(int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits buffers of items it collects from the current Observable.
+
+
buffer(int, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits buffers of items it collects from the current Observable.
+
+
buffer(int, int, Supplier<U>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits buffers of items it collects from the current Observable.
+
+
buffer(int, Supplier<U>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits buffers of items it collects from the current Observable.
+
+
buffer(long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits buffers of items it collects from the current Observable.
+
+
buffer(long, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits buffers of items it collects from the current Observable.
+
+
buffer(long, long, TimeUnit, Scheduler, Supplier<U>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits buffers of items it collects from the current Observable.
+
+
buffer(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits buffers of items it collects from the current Observable.
+
+
buffer(long, TimeUnit, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits buffers of items it collects from the current Observable.
+
+
buffer(long, TimeUnit, Scheduler, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits buffers of items it collects from the current Observable.
+
+
buffer(long, TimeUnit, Scheduler, int, Supplier<U>, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits buffers of items it collects from the current Observable.
+
+
buffer(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits buffers of items it collects from the current Observable.
+
+
buffer(ObservableSource<? extends TOpening>, Function<? super TOpening, ? extends ObservableSource<? extends TClosing>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits buffers of items it collects from the current Observable.
+
+
buffer(ObservableSource<? extends TOpening>, Function<? super TOpening, ? extends ObservableSource<? extends TClosing>>, Supplier<U>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits buffers of items it collects from the current Observable.
+
+
buffer(ObservableSource<B>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits non-overlapping buffered items from the current Observable each time the + specified boundary ObservableSource emits an item.
+
+
buffer(ObservableSource<B>, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits non-overlapping buffered items from the current Observable each time the + specified boundary ObservableSource emits an item.
+
+
buffer(ObservableSource<B>, Supplier<U>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits non-overlapping buffered items from the current Observable each time the + specified boundary ObservableSource emits an item.
+
+
bufferSize() - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns the default internal buffer size used by most async operators.
+
+
bufferSize() - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns the default 'island' size or capacity-increment hint for unbounded buffers.
+
+
+ + + +

C

+
+
cache() - Method in class io.reactivex.rxjava3.core.Completable
+
+
Subscribes to this Completable only once, when the first CompletableObserver + subscribes to the result Completable, caches its terminal event + and relays/replays it to observers.
+
+
cache() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that subscribes to this Publisher lazily, caches all of its events + and replays them, in the same order as received, to all the downstream subscribers.
+
+
cache() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that subscribes to this Maybe lazily, caches its event + and replays it, to all the downstream subscribers.
+
+
cache() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that subscribes to the current Observable lazily, caches all of its events + and replays them, in the same order as received, to all the downstream observers.
+
+
cache() - Method in class io.reactivex.rxjava3.core.Single
+
+
Stores the success value or exception from the current Single and replays it to late SingleObservers.
+
+
cacheWithInitialCapacity(int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that subscribes to this Publisher lazily, caches all of its events + and replays them, in the same order as received, to all the downstream subscribers.
+
+
cacheWithInitialCapacity(int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that subscribes to the current Observable lazily, caches all of its events + and replays them, in the same order as received, to all the downstream observers.
+
+
cancel() - Method in interface io.reactivex.rxjava3.functions.Cancellable
+
+
Cancel the action or free a resource.
+
+
cancel() - Method in class io.reactivex.rxjava3.observers.DefaultObserver
+
+
Cancels the upstream's disposable.
+
+
cancel() - Method in class io.reactivex.rxjava3.subscribers.DefaultSubscriber
+
+
Cancels the upstream's Subscription.
+
+
cancel() - Method in class io.reactivex.rxjava3.subscribers.DisposableSubscriber
+
+
Cancels the Subscription set via DisposableSubscriber.onSubscribe(Subscription) or makes sure a + Subscription set asynchronously (later) is cancelled immediately.
+
+
cancel() - Method in class io.reactivex.rxjava3.subscribers.SafeSubscriber
+
 
+
cancel() - Method in class io.reactivex.rxjava3.subscribers.SerializedSubscriber
+
 
+
cancel() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
 
+
Cancellable - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface that has a single cancel method + that can throw.
+
+
cast(Class<U>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items emitted by the current Flowable, converted to the specified + type.
+
+
cast(Class<? extends U>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Casts the success value of the current Maybe into the target type or signals a + ClassCastException if not compatible.
+
+
cast(Class<U>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items emitted by the current Observable, converted to the specified + type.
+
+
cast(Class<? extends U>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Casts the success value of the current Single into the target type or signals a + ClassCastException if not compatible.
+
+
CheckReturnValue - Annotation Type in io.reactivex.rxjava3.annotations
+
+
Marks methods whose return values should be checked.
+
+
checkSubscriptionOnce - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
 
+
cleanupBuffer() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
+
Makes sure the item cached by the head node in a bounded + ReplayProcessor is released (as it is never part of a replay).
+
+
cleanupBuffer() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
+
Makes sure the item cached by the head node in a bounded + ReplaySubject is released (as it is never part of a replay).
+
+
clear() - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable
+
+
Atomically clears the container, then disposes all the previously contained Disposables.
+
+
clear() - Method in interface io.reactivex.rxjava3.operators.SimpleQueue
+
+
Removes all enqueued items from this queue.
+
+
clear() - Method in class io.reactivex.rxjava3.operators.SpscArrayQueue
+
 
+
clear() - Method in class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue
+
 
+
clockDriftTolerance() - Static method in class io.reactivex.rxjava3.core.Scheduler
+
+
Returns the clock drift tolerance in nanoseconds.
+
+
collect(Supplier<? extends U>, BiConsumer<? super U, ? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Collects items emitted by the finite source Publisher into a single mutable data structure and returns + a Single that emits this structure.
+
+
collect(Collector<? super T, A, R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Collects the finite upstream's values into a container via a Stream Collector callback set and emits + it as the success result.
+
+
collect(Supplier<? extends U>, BiConsumer<? super U, ? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Collects items emitted by the finite source Observable into a single mutable data structure and returns + a Single that emits this structure.
+
+
collect(Collector<? super T, A, R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Collects the finite upstream's values into a container via a Stream Collector callback set and emits + it as the success result as a Single.
+
+
collect(Supplier<? extends C>, BiConsumer<? super C, ? super T>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Collect the elements in each rail into a collection supplied via a collectionSupplier + and collected into with a collector action, emitting the collection at the end.
+
+
collect(Collector<T, A, R>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Reduces all values within a 'rail' and across 'rails' with a callbacks + of the given Collector into one Flowable containing a single value.
+
+
collectInto(U, BiConsumer<? super U, ? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Collects items emitted by the finite source Publisher into a single mutable data structure and returns + a Single that emits this structure.
+
+
collectInto(U, BiConsumer<? super U, ? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Collects items emitted by the finite source Observable into a single mutable data structure and returns + a Single that emits this structure.
+
+
combineLatest(Iterable<? extends Publisher<? extends T>>, Function<? super Object[], ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function.
+
+
combineLatest(Iterable<? extends Publisher<? extends T>>, Function<? super Object[], ? extends R>, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function.
+
+
combineLatest(Publisher<? extends T1>, Publisher<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines two source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from either of the source Publishers, where this + aggregation is defined by a specified function.
+
+
combineLatest(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Function3<? super T1, ? super T2, ? super T3, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines three source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function.
+
+
combineLatest(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines four source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function.
+
+
combineLatest(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines five source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function.
+
+
combineLatest(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>, Publisher<? extends T6>, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines six source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function.
+
+
combineLatest(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>, Publisher<? extends T6>, Publisher<? extends T7>, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines seven source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function.
+
+
combineLatest(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>, Publisher<? extends T6>, Publisher<? extends T7>, Publisher<? extends T8>, Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines eight source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function.
+
+
combineLatest(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>, Publisher<? extends T6>, Publisher<? extends T7>, Publisher<? extends T8>, Publisher<? extends T9>, Function9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines nine source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function.
+
+
combineLatest(Iterable<? extends ObservableSource<? extends T>>, Function<? super Object[], ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of + the returned ObservableSources each time an item is received from any of the returned ObservableSources, where this + aggregation is defined by a specified function.
+
+
combineLatest(Iterable<? extends ObservableSource<? extends T>>, Function<? super Object[], ? extends R>, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines an Iterable of source ObservableSources by emitting an item that aggregates the latest values of each of + the returned ObservableSources each time an item is received from any of the returned ObservableSources, where this + aggregation is defined by a specified function.
+
+
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines two source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from either of the ObservableSources, where this + aggregation is defined by a specified function.
+
+
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, Function3<? super T1, ? super T2, ? super T3, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines three source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function.
+
+
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines four source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function.
+
+
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines five source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function.
+
+
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines six source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function.
+
+
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, ObservableSource<? extends T7>, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines seven source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function.
+
+
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, ObservableSource<? extends T7>, ObservableSource<? extends T8>, Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines eight source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function.
+
+
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, ObservableSource<? extends T7>, ObservableSource<? extends T8>, ObservableSource<? extends T9>, Function9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines nine source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function.
+
+
combineLatestArray(Publisher<? extends T>[], Function<? super Object[], ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function.
+
+
combineLatestArray(Publisher<? extends T>[], Function<? super Object[], ? extends R>, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function.
+
+
combineLatestArray(ObservableSource<? extends T>[], Function<? super Object[], ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines an array of source ObservableSources by emitting an item that aggregates the latest values of each of + the ObservableSources each time an item is received from any of the returned ObservableSources, where this + aggregation is defined by a specified function.
+
+
combineLatestArray(ObservableSource<? extends T>[], Function<? super Object[], ? extends R>, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines an array of source ObservableSources by emitting an item that aggregates the latest values of each of + the ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function.
+
+
combineLatestArrayDelayError(Publisher<? extends T>[], Function<? super Object[], ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function.
+
+
combineLatestArrayDelayError(Publisher<? extends T>[], Function<? super Object[], ? extends R>, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function and delays any error from the sources until + all source Publishers terminate.
+
+
combineLatestArrayDelayError(ObservableSource<? extends T>[], Function<? super Object[], ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines an array of ObservableSources by emitting an item that aggregates the latest values of each of + the ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function.
+
+
combineLatestArrayDelayError(ObservableSource<? extends T>[], Function<? super Object[], ? extends R>, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines an array of ObservableSources by emitting an item that aggregates the latest values of each of + the ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function and delays any error from the sources until + all source ObservableSources terminate.
+
+
combineLatestDelayError(Iterable<? extends Publisher<? extends T>>, Function<? super Object[], ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function and delays any error from the sources until + all source Publishers terminate.
+
+
combineLatestDelayError(Iterable<? extends Publisher<? extends T>>, Function<? super Object[], ? extends R>, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function and delays any error from the sources until + all source Publishers terminate.
+
+
combineLatestDelayError(Iterable<? extends ObservableSource<? extends T>>, Function<? super Object[], ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines an Iterable of ObservableSources by emitting an item that aggregates the latest values of each of + the ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function and delays any error from the sources until + all source ObservableSources terminate.
+
+
combineLatestDelayError(Iterable<? extends ObservableSource<? extends T>>, Function<? super Object[], ? extends R>, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Combines an Iterable of ObservableSources by emitting an item that aggregates the latest values of each of + the ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function and delays any error from the sources until + all source ObservableSources terminate.
+
+
Completable - Class in io.reactivex.rxjava3.core
+
+
The Completable class represents a deferred computation without any value but + only indication for completion or exception.
+
+
Completable() - Constructor for class io.reactivex.rxjava3.core.Completable
+
 
+
CompletableConverter<R> - Interface in io.reactivex.rxjava3.core
+
+
Convenience interface and callback used by the Completable.to(io.reactivex.rxjava3.core.CompletableConverter<? extends R>) operator to turn a Completable into another + value fluently.
+
+
CompletableEmitter - Interface in io.reactivex.rxjava3.core
+
+
Abstraction over an RxJava CompletableObserver that allows associating + a resource with it.
+
+
CompletableObserver - Interface in io.reactivex.rxjava3.core
+
+
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
+
+
CompletableOnSubscribe - Interface in io.reactivex.rxjava3.core
+
+
A functional interface that has a subscribe() method that receives + a CompletableEmitter instance that allows pushing + an event in a cancellation-safe manner.
+
+
CompletableOperator - Interface in io.reactivex.rxjava3.core
+
+
Interface to map/wrap a downstream observer to an upstream observer.
+
+
CompletableSource - Interface in io.reactivex.rxjava3.core
+
+
Represents a basic Completable source base interface, + consumable via an CompletableObserver.
+
+
CompletableSubject - Class in io.reactivex.rxjava3.subjects
+
+
Represents a hot Completable-like source and consumer of events similar to Subjects.
+
+
CompletableTransformer - Interface in io.reactivex.rxjava3.core
+
+
Convenience interface and callback used by the compose operator to turn a Completable into another + Completable fluently.
+
+
complete() - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that completes immediately when subscribed to.
+
+
completions - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
The number of completions.
+
+
compose(CompletableTransformer) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Calls the given transformer function with this instance and returns the function's resulting + CompletableSource wrapped with Completable.wrap(CompletableSource).
+
+
compose(FlowableTransformer<? super T, ? extends R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Transform the current Flowable by applying a particular FlowableTransformer function to it.
+
+
compose(MaybeTransformer<? super T, ? extends R>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Transform a Maybe by applying a particular MaybeTransformer function to it.
+
+
compose(ObservableTransformer<? super T, ? extends R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Transform the current Observable by applying a particular ObservableTransformer function to it.
+
+
compose(SingleTransformer<? super T, ? extends R>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Transform a Single by applying a particular SingleTransformer function to it.
+
+
compose(ParallelTransformer<T, U>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Allows composing operators, in assembly time, on top of this ParallelFlowable + and returns another ParallelFlowable with composed features.
+
+
CompositeDisposable - Class in io.reactivex.rxjava3.disposables
+
+
A disposable container that can hold onto multiple other Disposables and + offers O(1) time complexity for CompositeDisposable.add(Disposable), CompositeDisposable.remove(Disposable) and CompositeDisposable.delete(Disposable) + operations.
+
+
CompositeDisposable() - Constructor for class io.reactivex.rxjava3.disposables.CompositeDisposable
+
+
Creates an empty CompositeDisposable.
+
+
CompositeDisposable(Disposable...) - Constructor for class io.reactivex.rxjava3.disposables.CompositeDisposable
+
+
Creates a CompositeDisposable with the given array of initial Disposable elements.
+
+
CompositeDisposable(Iterable<? extends Disposable>) - Constructor for class io.reactivex.rxjava3.disposables.CompositeDisposable
+
+
Creates a CompositeDisposable with the given Iterable sequence of initial Disposable elements.
+
+
CompositeException - Exception in io.reactivex.rxjava3.exceptions
+
+
Represents an exception that is a composite of one or more other exceptions.
+
+
CompositeException(Throwable...) - Constructor for exception io.reactivex.rxjava3.exceptions.CompositeException
+
+
Constructs a CompositeException with the given array of Throwables as the + list of suppressed exceptions.
+
+
CompositeException(Iterable<? extends Throwable>) - Constructor for exception io.reactivex.rxjava3.exceptions.CompositeException
+
+
Constructs a CompositeException with the given array of Throwables as the + list of suppressed exceptions.
+
+
COMPUTATION - Static variable in annotation type io.reactivex.rxjava3.annotations.SchedulerSupport
+
+
The operator/class runs on RxJava's computation + scheduler or takes timing information from it.
+
+
computation() - Static method in class io.reactivex.rxjava3.schedulers.Schedulers
+
+
Returns a default, shared Scheduler instance intended for computational work.
+
+
concat(Iterable<? extends CompletableSource>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which completes only when all sources complete, one after another.
+
+
concat(Publisher<? extends CompletableSource>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which completes only when all sources complete, one after another.
+
+
concat(Publisher<? extends CompletableSource>, int) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which completes only when all sources complete, one after another.
+
+
concat(Iterable<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates elements of each Publisher provided via an Iterable sequence into a single sequence + of elements without interleaving them.
+
+
concat(Publisher<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source + Publisher, one after the other, without interleaving them.
+
+
concat(Publisher<? extends Publisher<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source + Publisher, one after the other, without interleaving them.
+
+
concat(Publisher<? extends T>, Publisher<? extends T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items emitted by two Publishers, one after the other, without + interleaving them.
+
+
concat(Publisher<? extends T>, Publisher<? extends T>, Publisher<? extends T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items emitted by three Publishers, one after the other, without + interleaving them.
+
+
concat(Publisher<? extends T>, Publisher<? extends T>, Publisher<? extends T>, Publisher<? extends T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items emitted by four Publishers, one after the other, without + interleaving them.
+
+
concat(Iterable<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by + an Iterable sequence as a Flowable sequence.
+
+
concat(MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Flowable that emits the items emitted by two MaybeSources, one after the other.
+
+
concat(MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Flowable that emits the items emitted by three MaybeSources, one after the other.
+
+
concat(MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Flowable that emits the items emitted by four MaybeSources, one after the other.
+
+
concat(Publisher<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by + a Publisher sequence as a Flowable sequence.
+
+
concat(Publisher<? extends MaybeSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by + a Publisher sequence as a Flowable sequence.
+
+
concat(Iterable<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates elements of each ObservableSource provided via an Iterable sequence into a single sequence + of elements without interleaving them.
+
+
concat(ObservableSource<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the + ObservableSource, one after the other, without interleaving them.
+
+
concat(ObservableSource<? extends ObservableSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the outer + ObservableSource, one after the other, without interleaving them.
+
+
concat(ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items emitted by two ObservableSources, one after the other, without + interleaving them.
+
+
concat(ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items emitted by three ObservableSources, one after the other, without + interleaving them.
+
+
concat(ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items emitted by four ObservableSources, one after the other, without + interleaving them.
+
+
concat(Iterable<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by + an Iterable sequence.
+
+
concat(ObservableSource<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by + an ObservableSource sequence.
+
+
concat(Publisher<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by + a Publisher sequence.
+
+
concat(Publisher<? extends SingleSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by + a Publisher sequence and prefetched by the specified amount.
+
+
concat(SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Flowable that emits the items emitted by two SingleSources, one after the other.
+
+
concat(SingleSource<? extends T>, SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Flowable that emits the items emitted by three SingleSources, one after the other.
+
+
concat(SingleSource<? extends T>, SingleSource<? extends T>, SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Flowable that emits the items emitted by four SingleSources, one after the other.
+
+
concatArray(CompletableSource...) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which completes only when all sources complete, one after another.
+
+
concatArray(Publisher<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates a variable number of Publisher sources.
+
+
concatArray(MaybeSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources in the array + as a Flowable sequence.
+
+
concatArray(ObservableSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates a variable number of ObservableSource sources.
+
+
concatArray(SingleSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in + an array.
+
+
concatArrayDelayError(CompletableSource...) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which completes only when all sources complete, one after another.
+
+
concatArrayDelayError(Publisher<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates a variable number of Publisher sources and delays errors from any of them + till all terminate.
+
+
concatArrayDelayError(MaybeSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenates a variable number of MaybeSource sources and delays errors from any of them + till all terminate as a Flowable sequence.
+
+
concatArrayDelayError(ObservableSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates a variable number of ObservableSource sources and delays errors from any of them + till all terminate.
+
+
concatArrayDelayError(SingleSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in + an array.
+
+
concatArrayEager(Publisher<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates an array of Publishers eagerly into a single stream of values.
+
+
concatArrayEager(int, int, Publisher<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates an array of Publishers eagerly into a single stream of values.
+
+
concatArrayEager(MaybeSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenates a sequence of MaybeSource eagerly into a Flowable sequence.
+
+
concatArrayEager(ObservableSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates an array of ObservableSources eagerly into a single stream of values.
+
+
concatArrayEager(int, int, ObservableSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates an array of ObservableSources eagerly into a single stream of values.
+
+
concatArrayEager(SingleSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenates a sequence of SingleSource eagerly into a single stream of values.
+
+
concatArrayEagerDelayError(Publisher<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates an array of Publishers eagerly into a single stream of values + and delaying any errors until all sources terminate.
+
+
concatArrayEagerDelayError(int, int, Publisher<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates an array of Publishers eagerly into a single stream of values + and delaying any errors until all sources terminate.
+
+
concatArrayEagerDelayError(MaybeSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenates a sequence of MaybeSource eagerly into a Flowable sequence.
+
+
concatArrayEagerDelayError(ObservableSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates an array of ObservableSources eagerly into a single stream of values + and delaying any errors until all sources terminate.
+
+
concatArrayEagerDelayError(int, int, ObservableSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates an array of ObservableSources eagerly into a single stream of values + and delaying any errors until all sources terminate.
+
+
concatArrayEagerDelayError(SingleSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenates a sequence of SingleSource eagerly into a single stream of values.
+
+
concatDelayError(Iterable<? extends CompletableSource>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which completes only when all sources complete, one after another.
+
+
concatDelayError(Publisher<? extends CompletableSource>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which completes only when all sources complete, one after another.
+
+
concatDelayError(Publisher<? extends CompletableSource>, int) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which completes only when all sources complete, one after another.
+
+
concatDelayError(Iterable<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates the Iterable sequence of Publishers into a single sequence by subscribing to each Publisher, + one after the other, one at a time and delays any errors till the all inner Publishers terminate.
+
+
concatDelayError(Publisher<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, + one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.
+
+
concatDelayError(Publisher<? extends Publisher<? extends T>>, int, boolean) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, + one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.
+
+
concatDelayError(Iterable<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenates the Iterable sequence of MaybeSources into a single sequence by subscribing to each MaybeSource, + one after the other, one at a time and delays any errors till the all inner MaybeSources terminate + as a Flowable sequence.
+
+
concatDelayError(Publisher<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenates the Publisher sequence of MaybeSources into a single sequence by subscribing to each inner MaybeSource, + one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate + as a Flowable sequence.
+
+
concatDelayError(Publisher<? extends MaybeSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenates the Publisher sequence of MaybeSources into a single sequence by subscribing to each inner MaybeSource, + one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate + as a Flowable sequence.
+
+
concatDelayError(Iterable<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates the Iterable sequence of ObservableSources into a single Observable sequence + by subscribing to each ObservableSource, one after the other, one at a time and delays any errors till + the all inner ObservableSources terminate.
+
+
concatDelayError(ObservableSource<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates the ObservableSource sequence of ObservableSources into a single Observable sequence + by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the + all inner and the outer ObservableSources terminate.
+
+
concatDelayError(ObservableSource<? extends ObservableSource<? extends T>>, int, boolean) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates the ObservableSource sequence of ObservableSources into a single sequence by subscribing to each inner ObservableSource, + one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.
+
+
concatDelayError(Iterable<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenates the Iterable sequence of SingleSources into a single sequence by subscribing to each SingleSource, + one after the other, one at a time and delays any errors till the all inner SingleSources terminate + as a Flowable sequence.
+
+
concatDelayError(Publisher<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenates the Publisher sequence of SingleSources into a single sequence by subscribing to each inner SingleSource, + one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate + as a Flowable sequence.
+
+
concatDelayError(Publisher<? extends SingleSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenates the Publisher sequence of SingleSources into a single sequence by subscribing to each inner SingleSource, + one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate + as a Flowable sequence.
+
+
concatEager(Iterable<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates a sequence of Publishers eagerly into a single stream of values.
+
+
concatEager(Iterable<? extends Publisher<? extends T>>, int, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates a sequence of Publishers eagerly into a single stream of values and + runs a limited number of inner sequences at once.
+
+
concatEager(Publisher<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.
+
+
concatEager(Publisher<? extends Publisher<? extends T>>, int, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates a Publisher sequence of Publishers eagerly into a single stream of values and + runs a limited number of inner sequences at once.
+
+
concatEager(Iterable<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenates a sequence of MaybeSources eagerly into a Flowable sequence.
+
+
concatEager(Iterable<? extends MaybeSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenates a sequence of MaybeSources eagerly into a Flowable sequence and + runs a limited number of the inner sequences at once.
+
+
concatEager(Publisher<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence.
+
+
concatEager(Publisher<? extends MaybeSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence, + running at most the given number of inner MaybeSources at once.
+
+
concatEager(Iterable<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates a sequence of ObservableSources eagerly into a single stream of values.
+
+
concatEager(Iterable<? extends ObservableSource<? extends T>>, int, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates a sequence of ObservableSources eagerly into a single stream of values and + runs a limited number of inner sequences at once.
+
+
concatEager(ObservableSource<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.
+
+
concatEager(ObservableSource<? extends ObservableSource<? extends T>>, int, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values + and runs a limited number of inner sequences at once.
+
+
concatEager(Iterable<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values.
+
+
concatEager(Iterable<? extends SingleSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values and + runs a limited number of the inner sources at once.
+
+
concatEager(Publisher<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values.
+
+
concatEager(Publisher<? extends SingleSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values and + runs a limited number of those inner SingleSources at once.
+
+
concatEagerDelayError(Iterable<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates a sequence of Publishers eagerly into a single stream of values, + delaying errors until all the inner sequences terminate.
+
+
concatEagerDelayError(Iterable<? extends Publisher<? extends T>>, int, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates a sequence of Publishers eagerly into a single stream of values, + delaying errors until all the inner sequences terminate and runs a limited number + of inner sequences at once.
+
+
concatEagerDelayError(Publisher<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates a Publisher sequence of Publishers eagerly into a single stream of values, + delaying errors until all the inner and the outer sequences terminate.
+
+
concatEagerDelayError(Publisher<? extends Publisher<? extends T>>, int, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Concatenates a Publisher sequence of Publishers eagerly into a single stream of values, + delaying errors until all the inner and outer sequences terminate and runs a limited number of inner + sequences at once.
+
+
concatEagerDelayError(Iterable<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenates a sequence of MaybeSources eagerly into a Flowable sequence, + delaying errors until all inner MaybeSources terminate.
+
+
concatEagerDelayError(Iterable<? extends MaybeSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenates a sequence of MaybeSources eagerly into a Flowable sequence, + delaying errors until all inner MaybeSources terminate and + runs a limited number of inner MaybeSources at once.
+
+
concatEagerDelayError(Publisher<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence, + delaying errors until all the inner and the outer sequence terminate.
+
+
concatEagerDelayError(Publisher<? extends MaybeSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence, + delaying errors until all the inner and the outer sequence terminate and + runs a limited number of the inner MaybeSources at once.
+
+
concatEagerDelayError(Iterable<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates a sequence of ObservableSources eagerly into a single stream of values, + delaying errors until all the inner sequences terminate.
+
+
concatEagerDelayError(Iterable<? extends ObservableSource<? extends T>>, int, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates a sequence of ObservableSources eagerly into a single stream of values, + delaying errors until all the inner sequences terminate and runs a limited number of inner + sequences at once.
+
+
concatEagerDelayError(ObservableSource<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values, + delaying errors until all the inner and the outer sequence terminate.
+
+
concatEagerDelayError(ObservableSource<? extends ObservableSource<? extends T>>, int, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values, + delaying errors until all the inner and the outer sequence terminate and runs a limited number of inner sequences at once.
+
+
concatEagerDelayError(Iterable<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values, + delaying errors until all the inner sources terminate.
+
+
concatEagerDelayError(Iterable<? extends SingleSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values, + delaying errors until all the inner sources terminate.
+
+
concatEagerDelayError(Publisher<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values, + delaying errors until all the inner and the outer sequence terminate.
+
+
concatEagerDelayError(Publisher<? extends SingleSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values, + running at most the specified number of those inner SingleSources at once and + delaying errors until all the inner and the outer sequence terminate.
+
+
concatMap(Function<? super T, ? extends Publisher<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a new Flowable that emits items resulting from applying a function that you supply to each item + emitted by the current Flowable, where that function returns a Publisher, and then emitting the items + that result from concatenating those returned Publishers.
+
+
concatMap(Function<? super T, ? extends Publisher<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a new Flowable that emits items resulting from applying a function that you supply to each item + emitted by the current Flowable, where that function returns a Publisher, and then emitting the items + that result from concatenating those returned Publishers.
+
+
concatMap(Function<? super T, ? extends Publisher<? extends R>>, int, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a new Flowable that emits items resulting from applying a function (on a designated scheduler) + that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then emitting the items + that result from concatenating those returned Publishers.
+
+
concatMap(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that is based on applying a specified function to the item emitted by the current Maybe, + where that function returns a MaybeSource.
+
+
concatMap(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a new Observable that emits items resulting from applying a function that you supply to each item + emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items + that result from concatenating those returned ObservableSources.
+
+
concatMap(Function<? super T, ? extends ObservableSource<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a new Observable that emits items resulting from applying a function that you supply to each item + emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items + that result from concatenating those returned ObservableSources.
+
+
concatMap(Function<? super T, ? extends ObservableSource<? extends R>>, int, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a new Observable that emits items resulting from applying a function that you supply to each item + emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items + that result from concatenating those returned ObservableSources.
+
+
concatMap(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that is based on applying a specified function to the item emitted by the current Single, + where that function returns a SingleSource.
+
+
concatMap(Function<? super T, ? extends Publisher<? extends R>>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Generates and concatenates Publishers on each 'rail', signalling errors immediately + and generating 2 publishers upfront.
+
+
concatMap(Function<? super T, ? extends Publisher<? extends R>>, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Generates and concatenates Publishers on each 'rail', signalling errors immediately + and using the given prefetch amount for generating Publishers upfront.
+
+
concatMapCompletable(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into CompletableSources and subscribes to them one after the + other completes.
+
+
concatMapCompletable(Function<? super T, ? extends CompletableSource>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into CompletableSources and subscribes to them one after the + other completes.
+
+
concatMapCompletable(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Completable that completes based on applying a specified function to the item emitted by the + current Maybe, where that function returns a Completable.
+
+
concatMapCompletable(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps each element of the current Observable into CompletableSources, subscribes to them one at a time in + order and waits until the upstream and all CompletableSources complete.
+
+
concatMapCompletable(Function<? super T, ? extends CompletableSource>, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps each element of the current Observable into CompletableSources, subscribes to them one at a time in + order and waits until the upstream and all CompletableSources complete.
+
+
concatMapCompletable(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Completable that completes based on applying a specified function to the item emitted by the + current Single, where that function returns a CompletableSource.
+
+
concatMapCompletableDelayError(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into CompletableSources and subscribes to them one after the + other terminates, delaying all errors till both this Flowable and all + inner CompletableSources terminate.
+
+
concatMapCompletableDelayError(Function<? super T, ? extends CompletableSource>, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into CompletableSources and subscribes to them one after the + other terminates, optionally delaying all errors till both this Flowable and all + inner CompletableSources terminate.
+
+
concatMapCompletableDelayError(Function<? super T, ? extends CompletableSource>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into CompletableSources and subscribes to them one after the + other terminates, optionally delaying all errors till both this Flowable and all + inner CompletableSources terminate.
+
+
concatMapCompletableDelayError(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the upstream items into CompletableSources and subscribes to them one after the + other terminates, delaying all errors till both the current Observable and all + inner CompletableSources terminate.
+
+
concatMapCompletableDelayError(Function<? super T, ? extends CompletableSource>, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the upstream items into CompletableSources and subscribes to them one after the + other terminates, optionally delaying all errors till both the current Observable and all + inner CompletableSources terminate.
+
+
concatMapCompletableDelayError(Function<? super T, ? extends CompletableSource>, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the upstream items into CompletableSources and subscribes to them one after the + other terminates, optionally delaying all errors till both the current Observable and all + inner CompletableSources terminate.
+
+
concatMapDelayError(Function<? super T, ? extends Publisher<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps each of the items into a Publisher, subscribes to them one after the other, + one at a time and emits their values in order + while delaying any error from either this or any of the inner Publishers + till all of them terminate.
+
+
concatMapDelayError(Function<? super T, ? extends Publisher<? extends R>>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps each of the items into a Publisher, subscribes to them one after the other, + one at a time and emits their values in order + while delaying any error from either this or any of the inner Publishers + till all of them terminate.
+
+
concatMapDelayError(Function<? super T, ? extends Publisher<? extends R>>, boolean, int, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps each of the upstream items into a Publisher, subscribes to them one after the other, + one at a time and emits their values in order + while executing the mapper function on the designated scheduler, delaying any error from either this or any of the + inner Publishers till all of them terminate.
+
+
concatMapDelayError(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps each of the items into an ObservableSource, subscribes to them one after the other, + one at a time and emits their values in order + while delaying any error from either this or any of the inner ObservableSources + till all of them terminate.
+
+
concatMapDelayError(Function<? super T, ? extends ObservableSource<? extends R>>, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps each of the items into an ObservableSource, subscribes to them one after the other, + one at a time and emits their values in order + while delaying any error from either this or any of the inner ObservableSources + till all of them terminate.
+
+
concatMapDelayError(Function<? super T, ? extends ObservableSource<? extends R>>, boolean, int, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps each of the items into an ObservableSource, subscribes to them one after the other, + one at a time and emits their values in order + while delaying any error from either this or any of the inner ObservableSources + till all of them terminate.
+
+
concatMapDelayError(Function<? super T, ? extends Publisher<? extends R>>, boolean) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Generates and concatenates Publishers on each 'rail', optionally delaying errors + and generating 2 publishers upfront.
+
+
concatMapDelayError(Function<? super T, ? extends Publisher<? extends R>>, int, boolean) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Generates and concatenates Publishers on each 'rail', optionally delaying errors + and using the given prefetch amount for generating Publishers upfront.
+
+
concatMapEager(Function<? super T, ? extends Publisher<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single + Publisher.
+
+
concatMapEager(Function<? super T, ? extends Publisher<? extends R>>, int, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single + Publisher.
+
+
concatMapEager(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single + Observable sequence.
+
+
concatMapEager(Function<? super T, ? extends ObservableSource<? extends R>>, int, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single + Observable sequence.
+
+
concatMapEagerDelayError(Function<? super T, ? extends Publisher<? extends R>>, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single + Publisher.
+
+
concatMapEagerDelayError(Function<? super T, ? extends Publisher<? extends R>>, boolean, int, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single + Flowable sequence.
+
+
concatMapEagerDelayError(Function<? super T, ? extends ObservableSource<? extends R>>, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single + Observable sequence.
+
+
concatMapEagerDelayError(Function<? super T, ? extends ObservableSource<? extends R>>, boolean, int, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single + Observable sequence.
+
+
concatMapIterable(Function<? super T, ? extends Iterable<? extends U>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that concatenate each item emitted by the current Flowable with the values in an + Iterable corresponding to that item that is generated by a selector.
+
+
concatMapIterable(Function<? super T, ? extends Iterable<? extends U>>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that concatenate each item emitted by the current Flowable with the values in an + Iterable corresponding to that item that is generated by a selector.
+
+
concatMapIterable(Function<? super T, ? extends Iterable<? extends U>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that concatenate each item emitted by the current Observable with the values in an + Iterable corresponding to that item that is generated by a selector.
+
+
concatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into MaybeSources and subscribes to them one after the + other succeeds or completes, emits their success value if available or terminates immediately if + either this Flowable or the current inner MaybeSource fail.
+
+
concatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into MaybeSources and subscribes to them one after the + other succeeds or completes, emits their success value if available or terminates immediately if + either this Flowable or the current inner MaybeSource fail.
+
+
concatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the upstream items into MaybeSources and subscribes to them one after the + other succeeds or completes, emits their success value if available or terminates immediately if + either the current Observable or the current inner MaybeSource fail.
+
+
concatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the upstream items into MaybeSources and subscribes to them one after the + other succeeds or completes, emits their success value if available or terminates immediately if + either the current Observable or the current inner MaybeSource fail.
+
+
concatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Maybe that is based on applying a specified function to the item emitted by the current Single, + where that function returns a MaybeSource.
+
+
concatMapMaybeDelayError(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into MaybeSources and subscribes to them one after the + other terminates, emits their success value if available and delaying all errors + till both this Flowable and all inner MaybeSources terminate.
+
+
concatMapMaybeDelayError(Function<? super T, ? extends MaybeSource<? extends R>>, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into MaybeSources and subscribes to them one after the + other terminates, emits their success value if available and optionally delaying all errors + till both this Flowable and all inner MaybeSources terminate.
+
+
concatMapMaybeDelayError(Function<? super T, ? extends MaybeSource<? extends R>>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into MaybeSources and subscribes to them one after the + other terminates, emits their success value if available and optionally delaying all errors + till both this Flowable and all inner MaybeSources terminate.
+
+
concatMapMaybeDelayError(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the upstream items into MaybeSources and subscribes to them one after the + other terminates, emits their success value if available and delaying all errors + till both the current Observable and all inner MaybeSources terminate.
+
+
concatMapMaybeDelayError(Function<? super T, ? extends MaybeSource<? extends R>>, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the upstream items into MaybeSources and subscribes to them one after the + other terminates, emits their success value if available and optionally delaying all errors + till both the current Observable and all inner MaybeSources terminate.
+
+
concatMapMaybeDelayError(Function<? super T, ? extends MaybeSource<? extends R>>, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the upstream items into MaybeSources and subscribes to them one after the + other terminates, emits their success value if available and optionally delaying all errors + till both the current Observable and all inner MaybeSources terminate.
+
+
concatMapSingle(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds, emits their success values or terminates immediately if + either this Flowable or the current inner SingleSource fail.
+
+
concatMapSingle(Function<? super T, ? extends SingleSource<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds, emits their success values or terminates immediately if + either this Flowable or the current inner SingleSource fail.
+
+
concatMapSingle(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe based on applying a specified function to the item emitted by the + current Maybe, where that function returns a Single.
+
+
concatMapSingle(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds, emits their success values or terminates immediately if + either the current Observable or the current inner SingleSource fail.
+
+
concatMapSingle(Function<? super T, ? extends SingleSource<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds, emits their success values or terminates immediately if + either the current Observable or the current inner SingleSource fail.
+
+
concatMapSingleDelayError(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds or fails, emits their success values and delays all errors + till both this Flowable and all inner SingleSources terminate.
+
+
concatMapSingleDelayError(Function<? super T, ? extends SingleSource<? extends R>>, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds or fails, emits their success values and optionally delays all errors + till both this Flowable and all inner SingleSources terminate.
+
+
concatMapSingleDelayError(Function<? super T, ? extends SingleSource<? extends R>>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds or fails, emits their success values and optionally delays errors + till both this Flowable and all inner SingleSources terminate.
+
+
concatMapSingleDelayError(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds or fails, emits their success values and delays all errors + till both the current Observable and all inner SingleSources terminate.
+
+
concatMapSingleDelayError(Function<? super T, ? extends SingleSource<? extends R>>, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds or fails, emits their success values and optionally delays all errors + till both the current Observable and all inner SingleSources terminate.
+
+
concatMapSingleDelayError(Function<? super T, ? extends SingleSource<? extends R>>, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds or fails, emits their success values and optionally delays errors + till both the current Observable and all inner SingleSources terminate.
+
+
concatMapStream(Function<? super T, ? extends Stream<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
+
+
concatMapStream(Function<? super T, ? extends Stream<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
+
+
concatMapStream(Function<? super T, ? extends Stream<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
+
+
concatWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Concatenates this Completable with another CompletableSource.
+
+
concatWith(Publisher<? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items emitted from the current Flowable, then the next, one after + the other, without interleaving them.
+
+
concatWith(SingleSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items from this Flowable followed by the success item or error event + of the other SingleSource.
+
+
concatWith(MaybeSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items from this Flowable followed by the success item or terminal events + of the other MaybeSource.
+
+
concatWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items from this Flowable and when it completes normally, the + other CompletableSource is subscribed to and the returned Flowable emits its terminal events.
+
+
concatWith(MaybeSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Flowable that emits the items emitted from the current Maybe, then the other MaybeSource, one after + the other, without interleaving them.
+
+
concatWith(ObservableSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that first emits the items emitted from the current Observable, then items + from the other ObservableSource without interleaving them.
+
+
concatWith(SingleSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items from the current Observable followed by the success item or error event + of the other SingleSource.
+
+
concatWith(MaybeSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items from the current Observable followed by the success item or terminal events + of the other MaybeSource.
+
+
concatWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items from the current Observable and when it completes normally, the + other CompletableSource is subscribed to and the returned Observable emits its terminal events.
+
+
concatWith(SingleSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Flowable that emits the item emitted by the current Single, then the item emitted by the + specified SingleSource.
+
+
ConditionalSubscriber<T> - Interface in io.reactivex.rxjava3.operators
+
+
A FlowableSubscriber with an additional ConditionalSubscriber.tryOnNext(Object) method that + tells the caller the specified value has been accepted or not.
+
+
connect(Consumer<? super Disposable>) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable
+
+
Instructs the ConnectableFlowable to begin emitting the items from its underlying + Flowable to its Subscribers.
+
+
connect() - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable
+
+
Instructs the ConnectableFlowable to begin emitting the items from its underlying + Flowable to its Subscribers.
+
+
connect(Consumer<? super Disposable>) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable
+
+
Instructs the ConnectableObservable to begin emitting the items from its underlying + Observable to its Observers.
+
+
connect() - Method in class io.reactivex.rxjava3.observables.ConnectableObservable
+
+
Instructs the ConnectableObservable to begin emitting the items from its underlying + Observable to its Observers.
+
+
ConnectableFlowable<T> - Class in io.reactivex.rxjava3.flowables
+
+
A ConnectableFlowable resembles an ordinary Flowable, except that it does not begin + emitting items when it is subscribed to, but only when its ConnectableFlowable.connect(io.reactivex.rxjava3.functions.Consumer<? super io.reactivex.rxjava3.disposables.Disposable>) method is called.
+
+
ConnectableFlowable() - Constructor for class io.reactivex.rxjava3.flowables.ConnectableFlowable
+
 
+
ConnectableObservable<T> - Class in io.reactivex.rxjava3.observables
+
+
A ConnectableObservable resembles an ordinary Observable, except that it does not begin + emitting items when it is subscribed to, but only when its ConnectableObservable.connect(io.reactivex.rxjava3.functions.Consumer<? super io.reactivex.rxjava3.disposables.Disposable>) method is called.
+
+
ConnectableObservable() - Constructor for class io.reactivex.rxjava3.observables.ConnectableObservable
+
 
+
Consumer<T> - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that accepts a single value.
+
+
contains(Object) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a Boolean that indicates whether the current Flowable emitted a + specified item.
+
+
contains(Object) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Single that emits a Boolean that indicates whether the current Maybe emitted a + specified item.
+
+
contains(Object) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a Boolean that indicates whether the current Observable emitted a + specified item.
+
+
contains(Object) - Method in class io.reactivex.rxjava3.core.Single
+
+
Signals true if the current Single signals a success value that is Object.equals(Object) with the value + provided.
+
+
contains(Object, BiPredicate<Object, Object>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Signals true if the current Single signals a success value that is equal with + the value provided by calling a BiPredicate.
+
+
count() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that counts the total number of items emitted by the current Flowable and emits + this count as a 64-bit Long.
+
+
count() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Single that counts the total number of items emitted (0 or 1) by the current Maybe and emits + this count as a 64-bit Long.
+
+
count() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that counts the total number of items emitted by the current Observable and emits + this count as a 64-bit Long.
+
+
create(CompletableOnSubscribe) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Provides an API (via a cold Completable) that bridges the reactive world with the callback-style world.
+
+
create(FlowableOnSubscribe<T>, BackpressureStrategy) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Provides an API (via a cold Flowable) that bridges the reactive world with the callback-style, + generally non-backpressured world.
+
+
create(MaybeOnSubscribe<T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Provides an API (via a cold Maybe) that bridges the reactive world with the callback-style world.
+
+
create(ObservableOnSubscribe<T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Provides an API (via a cold Observable) that bridges the reactive world with the callback-style world.
+
+
create(SingleOnSubscribe<T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Provides an API (via a cold Single) that bridges the reactive world with the callback-style world.
+
+
create() - Static method in class io.reactivex.rxjava3.observers.TestObserver
+
+
Constructs a non-forwarding TestObserver.
+
+
create(Observer<? super T>) - Static method in class io.reactivex.rxjava3.observers.TestObserver
+
+
Constructs a forwarding TestObserver.
+
+
create() - Static method in class io.reactivex.rxjava3.processors.AsyncProcessor
+
+
Creates a new AsyncProcessor.
+
+
create() - Static method in class io.reactivex.rxjava3.processors.BehaviorProcessor
+
+
Creates a BehaviorProcessor without a default item.
+
+
create() - Static method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
+
Constructs a fresh instance with the default Flowable.bufferSize() prefetch + amount and no refCount-behavior.
+
+
create(boolean) - Static method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
+
Constructs a fresh instance with the default Flowable.bufferSize() prefetch + amount and the optional refCount-behavior.
+
+
create(int) - Static method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
+
Constructs a fresh instance with the given prefetch amount and no refCount behavior.
+
+
create(int, boolean) - Static method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
+
Constructs a fresh instance with the given prefetch amount and the optional + refCount-behavior.
+
+
create() - Static method in class io.reactivex.rxjava3.processors.PublishProcessor
+
+
Constructs a PublishProcessor.
+
+
create() - Static method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
+
Creates an unbounded ReplayProcessor.
+
+
create(int) - Static method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
+
Creates an unbounded ReplayProcessor with the specified initial buffer capacity.
+
+
create() - Static method in class io.reactivex.rxjava3.processors.UnicastProcessor
+
+
Creates an UnicastSubject with an internal buffer capacity hint 16.
+
+
create(int) - Static method in class io.reactivex.rxjava3.processors.UnicastProcessor
+
+
Creates an UnicastProcessor with the given internal buffer capacity hint.
+
+
create(boolean) - Static method in class io.reactivex.rxjava3.processors.UnicastProcessor
+
+
Creates an UnicastProcessor with default internal buffer capacity hint and delay error flag.
+
+
create(int, Runnable) - Static method in class io.reactivex.rxjava3.processors.UnicastProcessor
+
+
Creates an UnicastProcessor with the given internal buffer capacity hint and a callback for + the case when the single Subscriber cancels its subscription or the + processor is terminated.
+
+
create(int, Runnable, boolean) - Static method in class io.reactivex.rxjava3.processors.UnicastProcessor
+
+
Creates an UnicastProcessor with the given internal buffer capacity hint, delay error flag and a callback for + the case when the single Subscriber cancels its subscription or + the processor is terminated.
+
+
create() - Static method in class io.reactivex.rxjava3.subjects.AsyncSubject
+
+
Creates a new AsyncProcessor.
+
+
create() - Static method in class io.reactivex.rxjava3.subjects.BehaviorSubject
+
+
Creates a BehaviorSubject without a default item.
+
+
create() - Static method in class io.reactivex.rxjava3.subjects.CompletableSubject
+
+
Creates a fresh CompletableSubject.
+
+
create() - Static method in class io.reactivex.rxjava3.subjects.MaybeSubject
+
+
Creates a fresh MaybeSubject.
+
+
create() - Static method in class io.reactivex.rxjava3.subjects.PublishSubject
+
+
Constructs a PublishSubject.
+
+
create() - Static method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
+
Creates an unbounded replay subject.
+
+
create(int) - Static method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
+
Creates an unbounded replay subject with the specified initial buffer capacity.
+
+
create() - Static method in class io.reactivex.rxjava3.subjects.SingleSubject
+
+
Creates a fresh SingleSubject.
+
+
create() - Static method in class io.reactivex.rxjava3.subjects.UnicastSubject
+
+
Creates an UnicastSubject with an internal buffer capacity hint 16.
+
+
create(int) - Static method in class io.reactivex.rxjava3.subjects.UnicastSubject
+
+
Creates an UnicastSubject with the given internal buffer capacity hint.
+
+
create(int, Runnable) - Static method in class io.reactivex.rxjava3.subjects.UnicastSubject
+
+
Creates an UnicastSubject with the given internal buffer capacity hint and a callback for + the case when the single Subscriber cancels its subscription + or the subject is terminated.
+
+
create(int, Runnable, boolean) - Static method in class io.reactivex.rxjava3.subjects.UnicastSubject
+
+
Creates an UnicastSubject with the given internal buffer capacity hint, delay error flag and + a callback for the case when the single Observer disposes its Disposable + or the subject is terminated.
+
+
create(boolean) - Static method in class io.reactivex.rxjava3.subjects.UnicastSubject
+
+
Creates an UnicastSubject with an internal buffer capacity hint 16 and given delay error flag.
+
+
create() - Static method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
+
Creates a TestSubscriber with Long.MAX_VALUE initial request amount.
+
+
create(long) - Static method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
+
Creates a TestSubscriber with the given initial request amount.
+
+
create(Subscriber<? super T>) - Static method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
+
Constructs a forwarding TestSubscriber.
+
+
createComputationScheduler(ThreadFactory) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Create an instance of the default Scheduler used for Schedulers.computation() + except using threadFactory for thread creation.
+
+
createDefault() - Static method in exception io.reactivex.rxjava3.exceptions.MissingBackpressureException
+
+
Constructs a new MissingBackpressureException with the + default message "Could not emit value due to lack of requests".
+
+
createDefault(T) - Static method in class io.reactivex.rxjava3.processors.BehaviorProcessor
+
+
Creates a BehaviorProcessor that emits the last item it observed and all subsequent items to each + Subscriber that subscribes to it.
+
+
createDefault(T) - Static method in class io.reactivex.rxjava3.subjects.BehaviorSubject
+
+
Creates a BehaviorSubject that emits the last item it observed and all subsequent items to each + Observer that subscribes to it.
+
+
createExecutorScheduler(Executor, boolean, boolean) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Create an instance of a Scheduler by wrapping an existing Executor.
+
+
createIoScheduler(ThreadFactory) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Create an instance of the default Scheduler used for Schedulers.io() + except using threadFactory for thread creation.
+
+
createNewThreadScheduler(ThreadFactory) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Create an instance of the default Scheduler used for Schedulers.newThread() + except using threadFactory for thread creation.
+
+
createOnComplete() - Static method in class io.reactivex.rxjava3.core.Notification
+
+
Returns the empty and stateless shared instance of a notification representing + an onComplete signal.
+
+
createOnError(Throwable) - Static method in class io.reactivex.rxjava3.core.Notification
+
+
Constructs an onError notification containing the error.
+
+
createOnNext(T) - Static method in class io.reactivex.rxjava3.core.Notification
+
+
Constructs an onNext notification containing the given value.
+
+
createSingleScheduler(ThreadFactory) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Create an instance of the default Scheduler used for Schedulers.single() + except using threadFactory for thread creation.
+
+
createWithSize(int) - Static method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
+
Creates a size-bounded ReplayProcessor.
+
+
createWithSize(int) - Static method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
+
Creates a size-bounded replay subject.
+
+
createWithTime(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
+
Creates a time-bounded ReplayProcessor.
+
+
createWithTime(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
+
Creates a time-bounded replay subject.
+
+
createWithTimeAndSize(long, TimeUnit, Scheduler, int) - Static method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
+
Creates a time- and size-bounded ReplayProcessor.
+
+
createWithTimeAndSize(long, TimeUnit, Scheduler, int) - Static method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
+
Creates a time- and size-bounded replay subject.
+
+
createWorker() - Method in class io.reactivex.rxjava3.core.Scheduler
+
+
Retrieves or creates a new Scheduler.Worker that represents sequential execution of actions.
+
+
createWorker() - Method in class io.reactivex.rxjava3.schedulers.TestScheduler
+
 
+
CUSTOM - Static variable in annotation type io.reactivex.rxjava3.annotations.SchedulerSupport
+
+
A special value indicating the operator/class requires a scheduler to be manually specified.
+
+
+ + + +

D

+
+
debounce(Function<? super T, ? extends Publisher<U>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the + current Flowable that are followed by another item within a computed debounce duration.
+
+
debounce(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the + current Flowable that are followed by newer items before a timeout value expires.
+
+
debounce(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the + current Flowable that are followed by newer items before a timeout value expires on a specified + Scheduler.
+
+
debounce(long, TimeUnit, Scheduler, Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the + current Flowable that are followed by newer items before a timeout value expires on a specified + Scheduler.
+
+
debounce(Function<? super T, ? extends ObservableSource<U>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable, except that it drops items emitted by the + current Observable that are followed by another item within a computed debounce duration + denoted by an item emission or completion from a generated inner ObservableSource for that original item.
+
+
debounce(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable, except that it drops items emitted by the + current Observable that are followed by newer items before a timeout value expires.
+
+
debounce(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable, except that it drops items emitted by the + current Observable that are followed by newer items before a timeout value expires on a specified + Scheduler.
+
+
debounce(long, TimeUnit, Scheduler, Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable, except that it drops items emitted by the + current Observable that are followed by newer items before a timeout value expires on a specified + Scheduler.
+
+
DEFAULT_MESSAGE - Static variable in exception io.reactivex.rxjava3.exceptions.MissingBackpressureException
+
+
The default error message.
+
+
defaultIfEmpty(T) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items emitted by the current Flowable or a specified default item + if the current Flowable is empty.
+
+
defaultIfEmpty(T) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Single that emits the item emitted by the current Maybe or a specified default item + if the current Maybe is empty.
+
+
defaultIfEmpty(T) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items emitted by the current Observable or a specified default item + if the current Observable is empty.
+
+
DefaultObserver<T> - Class in io.reactivex.rxjava3.observers
+
+
Abstract base implementation of an Observer with support for cancelling a + subscription via DefaultObserver.cancel() (synchronously) and calls DefaultObserver.onStart() + when the subscription happens.
+
+
DefaultObserver() - Constructor for class io.reactivex.rxjava3.observers.DefaultObserver
+
 
+
DefaultSubscriber<T> - Class in io.reactivex.rxjava3.subscribers
+
+
Abstract base implementation of a Subscriber with + support for requesting via DefaultSubscriber.request(long), cancelling via + via DefaultSubscriber.cancel() (both synchronously) and calls DefaultSubscriber.onStart() + when the subscription happens.
+
+
DefaultSubscriber() - Constructor for class io.reactivex.rxjava3.subscribers.DefaultSubscriber
+
 
+
defer(Supplier<? extends CompletableSource>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Defers the subscription to a Completable instance returned by a supplier.
+
+
defer(Supplier<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that calls a Publisher factory to create a Publisher for each new Subscriber + that subscribes.
+
+
defer(Supplier<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Calls a Supplier for each individual MaybeObserver to return the actual MaybeSource source to + be subscribed to.
+
+
defer(Supplier<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that calls an ObservableSource factory to create an ObservableSource for each new Observer + that subscribes.
+
+
defer(Supplier<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Calls a Supplier for each individual SingleObserver to return the actual SingleSource to + be subscribed to.
+
+
delay(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which delays the emission of the completion event by the given time.
+
+
delay(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which delays the emission of the completion event by the given time while + running on the specified Scheduler.
+
+
delay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which delays the emission of the completion event, and optionally the error as well, by the given time while + running on the specified Scheduler.
+
+
delay(Function<? super T, ? extends Publisher<U>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that delays the emissions of the current Flowable via another Publisher on a + per-item basis.
+
+
delay(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a + specified delay.
+
+
delay(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a + specified delay.
+
+
delay(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a + specified delay.
+
+
delay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a + specified delay.
+
+
delay(Publisher<U>, Function<? super T, ? extends Publisher<V>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that delays the subscription to and emissions from the current Flowable via another + Publisher on a per-item basis.
+
+
delay(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a + specified delay.
+
+
delay(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a + specified delay.
+
+
delay(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a + specified delay.
+
+
delay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a + specified delay running on the specified Scheduler.
+
+
delay(Publisher<U>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Delays the emission of this Maybe until the given Publisher signals an item or completes.
+
+
delay(Function<? super T, ? extends ObservableSource<U>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that delays the emissions of the current Observable via + a per-item derived ObservableSource's item emission or termination, on a per source item basis.
+
+
delay(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a + specified delay.
+
+
delay(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a + specified delay.
+
+
delay(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a + specified delay.
+
+
delay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a + specified delay.
+
+
delay(ObservableSource<U>, Function<? super T, ? extends ObservableSource<V>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that delays the subscription to and emissions from the current Observable via + ObservableSources for the subscription itself and on a per-item basis.
+
+
delay(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Single
+
+
Delays the emission of the success signal from the current Single by the specified amount.
+
+
delay(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Single
+
+
Delays the emission of the success or error signal from the current Single by the specified amount.
+
+
delay(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Single
+
+
Delays the emission of the success signal from the current Single by the specified amount.
+
+
delay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Single
+
+
Delays the emission of the success or error signal from the current Single by the specified amount.
+
+
delaySubscription(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that delays the subscription to the upstream by a given amount of time.
+
+
delaySubscription(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that delays the subscription to the upstream by a given amount of time, + both waiting and subscribing on a given Scheduler.
+
+
delaySubscription(Publisher<U>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that delays the subscription to this Publisher + until the other Publisher emits an element or completes normally.
+
+
delaySubscription(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that delays the subscription to the current Flowable by a given amount of time.
+
+
delaySubscription(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that delays the subscription to the current Flowable by a given amount of time, + both waiting and subscribing on a given Scheduler.
+
+
delaySubscription(Publisher<U>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that delays the subscription to this Maybe + until the other Publisher emits an element or completes normally.
+
+
delaySubscription(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that delays the subscription to the current Maybe by a given amount of time.
+
+
delaySubscription(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that delays the subscription to the current Maybe by a given amount of time, + both waiting and subscribing on a given Scheduler.
+
+
delaySubscription(ObservableSource<U>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that delays the subscription to the current Observable + until the other ObservableSource emits an element or completes normally.
+
+
delaySubscription(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that delays the subscription to the current Observable by a given amount of time.
+
+
delaySubscription(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that delays the subscription to the current Observable by a given amount of time, + both waiting and subscribing on a given Scheduler.
+
+
delaySubscription(CompletableSource) - Method in class io.reactivex.rxjava3.core.Single
+
+
Delays the actual subscription to the current Single until the given other CompletableSource + completes.
+
+
delaySubscription(SingleSource<U>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Delays the actual subscription to the current Single until the given other SingleSource + signals success.
+
+
delaySubscription(ObservableSource<U>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Delays the actual subscription to the current Single until the given other ObservableSource + signals its first value or completes.
+
+
delaySubscription(Publisher<U>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Delays the actual subscription to the current Single until the given other Publisher + signals its first value or completes.
+
+
delaySubscription(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Single
+
+
Delays the actual subscription to the current Single until the given time delay elapsed.
+
+
delaySubscription(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Single
+
+
Delays the actual subscription to the current Single until the given time delay elapsed.
+
+
delete(Disposable) - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable
+
+
Removes (but does not dispose) the given Disposable if it is part of this + container.
+
+
delete(Disposable) - Method in interface io.reactivex.rxjava3.disposables.DisposableContainer
+
+
Removes but does not dispose the given disposable if it is part of this + container.
+
+
dematerialize(Function<? super T, Notification<R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that reverses the effect of materialize by transforming the + Notification objects extracted from the source items via a selector function + into their respective Subscriber signal types.
+
+
dematerialize(Function<? super T, Notification<R>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Maps the Notification success value of the current Maybe back into normal + onSuccess, onError or onComplete signals.
+
+
dematerialize(Function<? super T, Notification<R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that reverses the effect of materialize by transforming the + Notification objects extracted from the source items via a selector function + into their respective Observer signal types.
+
+
dematerialize(Function<? super T, Notification<R>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Maps the Notification success value of the current Single back into normal + onSuccess, onError or onComplete signals as a + Maybe source.
+
+
Disposable - Interface in io.reactivex.rxjava3.disposables
+
+
Represents a disposable resource.
+
+
DisposableCompletableObserver - Class in io.reactivex.rxjava3.observers
+
+
An abstract CompletableObserver that allows asynchronous cancellation by implementing Disposable.
+
+
DisposableCompletableObserver() - Constructor for class io.reactivex.rxjava3.observers.DisposableCompletableObserver
+
 
+
DisposableContainer - Interface in io.reactivex.rxjava3.disposables
+
+
Common interface to add and remove disposables from a container.
+
+
DisposableMaybeObserver<T> - Class in io.reactivex.rxjava3.observers
+
+
An abstract MaybeObserver that allows asynchronous cancellation by implementing Disposable.
+
+
DisposableMaybeObserver() - Constructor for class io.reactivex.rxjava3.observers.DisposableMaybeObserver
+
 
+
DisposableObserver<T> - Class in io.reactivex.rxjava3.observers
+
+
An abstract Observer that allows asynchronous cancellation by implementing Disposable.
+
+
DisposableObserver() - Constructor for class io.reactivex.rxjava3.observers.DisposableObserver
+
 
+
DisposableSingleObserver<T> - Class in io.reactivex.rxjava3.observers
+
+
An abstract SingleObserver that allows asynchronous cancellation by implementing Disposable.
+
+
DisposableSingleObserver() - Constructor for class io.reactivex.rxjava3.observers.DisposableSingleObserver
+
 
+
DisposableSubscriber<T> - Class in io.reactivex.rxjava3.subscribers
+
+
An abstract Subscriber that allows asynchronous, external cancellation by implementing Disposable.
+
+
DisposableSubscriber() - Constructor for class io.reactivex.rxjava3.subscribers.DisposableSubscriber
+
 
+
dispose() - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable
+
 
+
dispose() - Method in interface io.reactivex.rxjava3.disposables.Disposable
+
+
Dispose the resource, the operation should be idempotent.
+
+
dispose() - Method in class io.reactivex.rxjava3.disposables.SerialDisposable
+
 
+
dispose() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Cancel/dispose this test consumer.
+
+
dispose() - Method in class io.reactivex.rxjava3.observers.DisposableCompletableObserver
+
 
+
dispose() - Method in class io.reactivex.rxjava3.observers.DisposableMaybeObserver
+
 
+
dispose() - Method in class io.reactivex.rxjava3.observers.DisposableObserver
+
 
+
dispose() - Method in class io.reactivex.rxjava3.observers.DisposableSingleObserver
+
 
+
dispose() - Method in class io.reactivex.rxjava3.observers.ResourceCompletableObserver
+
+
Cancels the main disposable (if any) and disposes the resources associated with + this ResourceCompletableObserver (if any).
+
+
dispose() - Method in class io.reactivex.rxjava3.observers.ResourceMaybeObserver
+
+
Cancels the main disposable (if any) and disposes the resources associated with + this ResourceMaybeObserver (if any).
+
+
dispose() - Method in class io.reactivex.rxjava3.observers.ResourceObserver
+
+
Cancels the main disposable (if any) and disposes the resources associated with + this ResourceObserver (if any).
+
+
dispose() - Method in class io.reactivex.rxjava3.observers.ResourceSingleObserver
+
+
Cancels the main disposable (if any) and disposes the resources associated with + this ResourceSingleObserver (if any).
+
+
dispose() - Method in class io.reactivex.rxjava3.observers.SafeObserver
+
 
+
dispose() - Method in class io.reactivex.rxjava3.observers.SerializedObserver
+
 
+
dispose() - Method in class io.reactivex.rxjava3.observers.TestObserver
+
 
+
dispose() - Method in class io.reactivex.rxjava3.subscribers.DisposableSubscriber
+
 
+
dispose() - Method in class io.reactivex.rxjava3.subscribers.ResourceSubscriber
+
+
Cancels the subscription (if any) and disposes the resources associated with + this ResourceSubscriber (if any).
+
+
dispose() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
 
+
disposed() - Static method in interface io.reactivex.rxjava3.disposables.Disposable
+
+
Returns a shared, disposed Disposable instance.
+
+
distinct() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits all items emitted by the current Flowable that are distinct + based on Object.equals(Object) comparison.
+
+
distinct(Function<? super T, K>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits all items emitted by the current Flowable that are distinct according + to a key selector function and based on Object.equals(Object) comparison of the objects + returned by the key selector function.
+
+
distinct(Function<? super T, K>, Supplier<? extends Collection<? super K>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits all items emitted by the current Flowable that are distinct according + to a key selector function and based on Object.equals(Object) comparison of the objects + returned by the key selector function.
+
+
distinct() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits all items emitted by the current Observable that are distinct + based on Object.equals(Object) comparison.
+
+
distinct(Function<? super T, K>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits all items emitted by the current Observable that are distinct according + to a key selector function and based on Object.equals(Object) comparison of the objects + returned by the key selector function.
+
+
distinct(Function<? super T, K>, Supplier<? extends Collection<? super K>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits all items emitted by the current Observable that are distinct according + to a key selector function and based on Object.equals(Object) comparison of the objects + returned by the key selector function.
+
+
distinctUntilChanged() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits all items emitted by the current Flowable that are distinct from their + immediate predecessors based on Object.equals(Object) comparison.
+
+
distinctUntilChanged(Function<? super T, K>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits all items emitted by the current Flowable that are distinct from their + immediate predecessors, according to a key selector function and based on Object.equals(Object) comparison + of those objects returned by the key selector function.
+
+
distinctUntilChanged(BiPredicate<? super T, ? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits all items emitted by the current Flowable that are distinct from their + immediate predecessors when compared with each other via the provided comparator function.
+
+
distinctUntilChanged() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits all items emitted by the current Observable that are distinct from their + immediate predecessors based on Object.equals(Object) comparison.
+
+
distinctUntilChanged(Function<? super T, K>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits all items emitted by the current Observable that are distinct from their + immediate predecessors, according to a key selector function and based on Object.equals(Object) comparison + of those objects returned by the key selector function.
+
+
distinctUntilChanged(BiPredicate<? super T, ? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits all items emitted by the current Observable that are distinct from their + immediate predecessors when compared with each other via the provided comparator function.
+
+
doAfterNext(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Calls the specified consumer with the current item after this item has been emitted to the downstream.
+
+
doAfterNext(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Calls the specified Consumer with the current item after this item has been emitted to the downstream.
+
+
doAfterNext(Consumer<? super T>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Call the specified consumer with the current element passing through any 'rail' + after it has been delivered to downstream within the rail.
+
+
doAfterSuccess(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Calls the specified Consumer with the success item after this item has been emitted to the downstream.
+
+
doAfterSuccess(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Calls the specified consumer with the success item after this item has been emitted to the downstream.
+
+
doAfterTerminate(Action) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that calls the given onAfterTerminate Action after this Completable + completes normally or with an exception.
+
+
doAfterTerminate(Action) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Registers an Action to be called when this Publisher invokes either + onComplete or onError.
+
+
doAfterTerminate(Action) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Registers an Action to be called when this Maybe invokes either + onSuccess, + onComplete or onError.
+
+
doAfterTerminate(Action) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Registers an Action to be called when the current Observable invokes either + onComplete or onError.
+
+
doAfterTerminate(Action) - Method in class io.reactivex.rxjava3.core.Single
+
+
Registers an Action to be called after this Single invokes either onSuccess or onError.
+
+
doAfterTerminated(Action) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Run the specified Action when a 'rail' completes or signals an error.
+
+
doFinally(Action) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Calls the specified Action after this Completable signals onError or onComplete or gets disposed by + the downstream.
+
+
doFinally(Action) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Calls the specified action after this Flowable signals onError or onComplete or gets canceled by + the downstream.
+
+
doFinally(Action) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Calls the specified action after this Maybe signals onSuccess, onError or onComplete or gets disposed by + the downstream.
+
+
doFinally(Action) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Calls the specified action after the current Observable signals onError or onCompleted or gets disposed by + the downstream.
+
+
doFinally(Action) - Method in class io.reactivex.rxjava3.core.Single
+
+
Calls the specified action after this Single signals onSuccess or onError or gets disposed by + the downstream.
+
+
done - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
The latch that indicates an onError or onComplete has been called.
+
+
doOnCancel(Action) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Calls the cancel Action if the downstream cancels the sequence.
+
+
doOnCancel(Action) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Run the specified Action when a 'rail' receives a cancellation.
+
+
doOnComplete(Action) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which calls the given onComplete Action if this Completable completes.
+
+
doOnComplete(Action) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Invokes an Action just before the current Flowable calls onComplete.
+
+
doOnComplete(Action) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Invokes an Action just before the current Maybe calls onComplete.
+
+
doOnComplete(Action) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that invokes an Action when the current Observable calls onComplete.
+
+
doOnComplete(Action) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Run the specified Action when a 'rail' completes.
+
+
doOnDispose(Action) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Calls the shared Action if a CompletableObserver subscribed to the current + Completable disposes the common Disposable it received via onSubscribe.
+
+
doOnDispose(Action) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Calls the shared Action if a MaybeObserver subscribed to the current Maybe + disposes the common Disposable it received via onSubscribe.
+
+
doOnDispose(Action) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Calls the given shared Action if the downstream disposes the sequence.
+
+
doOnDispose(Action) - Method in class io.reactivex.rxjava3.core.Single
+
+
Calls the shared Action if a SingleObserver subscribed to the current Single + disposes the common Disposable it received via onSubscribe.
+
+
doOnEach(Consumer<? super Notification<T>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Invokes a Consumer with a Notification instances matching the signals emitted by the current Flowable + before they are forwarded to the downstream.
+
+
doOnEach(Subscriber<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Calls the appropriate methods of the given Subscriber when the current Flowable signals events before forwarding it + to the downstream.
+
+
doOnEach(Consumer<? super Notification<T>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that invokes a Consumer with the appropriate Notification + object when the current Observable signals an item or terminates.
+
+
doOnEach(Observer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that forwards the items and terminal events of the current + Observable to its Observers and to the given shared Observer instance.
+
+
doOnError(Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which calls the given onError Consumer if this Completable emits an error.
+
+
doOnError(Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Calls the given Consumer with the error Throwable if the current Flowable failed before forwarding it to + the downstream.
+
+
doOnError(Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Calls the shared Consumer with the error sent via onError for each + MaybeObserver that subscribes to the current Maybe.
+
+
doOnError(Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Calls the given Consumer with the error Throwable if the current Observable failed before forwarding it to + the downstream.
+
+
doOnError(Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Calls the shared consumer with the error sent via onError for each + SingleObserver that subscribes to the current Single.
+
+
doOnError(Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Call the specified consumer with the exception passing through any 'rail'.
+
+
doOnEvent(Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which calls the given onEvent Consumer with the Throwable for an onError + or null for an onComplete signal from this Completable before delivering the signal to the downstream.
+
+
doOnEvent(BiConsumer<? super T, ? super Throwable>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Calls the given onEvent callback with the (success value, null) for an onSuccess, (null, throwable) for + an onError or (null, null) for an onComplete signal from this Maybe before delivering said + signal to the downstream.
+
+
doOnEvent(BiConsumer<? super T, ? super Throwable>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Calls the shared consumer with the error sent via onError or the value + via onSuccess for each SingleObserver that subscribes to the current Single.
+
+
doOnLifecycle(Consumer<? super Disposable>, Action) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Calls the appropriate onXXX method (shared between all CompletableObservers) for the lifecycle events of + the sequence (subscription, disposal).
+
+
doOnLifecycle(Consumer<? super Subscription>, LongConsumer, Action) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Calls the appropriate onXXX method (shared between all Subscribers) for the lifecycle events of + the sequence (subscription, cancellation, requesting).
+
+
doOnLifecycle(Consumer<? super Disposable>, Action) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Calls the appropriate onXXX method (shared between all MaybeObservers) for the lifecycle events of + the sequence (subscription, disposal).
+
+
doOnLifecycle(Consumer<? super Disposable>, Action) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Calls the appropriate onXXX method (shared between all Observers) for the lifecycle events of + the sequence (subscription, disposal).
+
+
doOnLifecycle(Consumer<? super Disposable>, Action) - Method in class io.reactivex.rxjava3.core.Single
+
+
Calls the appropriate onXXX method (shared between all SingleObservers) for the lifecycle events of + the sequence (subscription, disposal).
+
+
doOnNext(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Calls the given Consumer with the value emitted by the current Flowable before forwarding it to the downstream.
+
+
doOnNext(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Calls the given Consumer with the value emitted by the current Observable before forwarding it to the downstream.
+
+
doOnNext(Consumer<? super T>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Call the specified consumer with the current element passing through any 'rail'.
+
+
doOnNext(Consumer<? super T>, ParallelFailureHandling) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Call the specified consumer with the current element passing through any 'rail' and + handles errors based on the given ParallelFailureHandling enumeration value.
+
+
doOnNext(Consumer<? super T>, BiFunction<? super Long, ? super Throwable, ParallelFailureHandling>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Call the specified consumer with the current element passing through any 'rail' and + handles errors based on the returned value by the handler function.
+
+
doOnRequest(LongConsumer) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Calls the given LongConsumer with the request amount from the downstream before forwarding it + to the current Flowable.
+
+
doOnRequest(LongConsumer) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Call the specified consumer with the request amount if any rail receives a request.
+
+
doOnSubscribe(Consumer<? super Disposable>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that calls the given onSubscribe callback with the disposable + that the downstream CompletableObservers receive upon subscription.
+
+
doOnSubscribe(Consumer<? super Subscription>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Calls the given Consumer with the Subscription provided by the current Flowable upon + subscription from the downstream before forwarding it to the subscriber's + onSubscribe method.
+
+
doOnSubscribe(Consumer<? super Disposable>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Calls the shared Consumer with the Disposable sent through the onSubscribe for each + MaybeObserver that subscribes to the current Maybe.
+
+
doOnSubscribe(Consumer<? super Disposable>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable so that it invokes the given Consumer when the current Observable is subscribed from + its Observers.
+
+
doOnSubscribe(Consumer<? super Disposable>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Calls the shared consumer with the Disposable sent through the onSubscribe for each + SingleObserver that subscribes to the current Single.
+
+
doOnSubscribe(Consumer<? super Subscription>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Call the specified callback when a 'rail' receives a Subscription from its upstream.
+
+
doOnSuccess(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Calls the shared Consumer with the success value sent via onSuccess for each + MaybeObserver that subscribes to the current Maybe.
+
+
doOnSuccess(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Calls the shared consumer with the success value sent via onSuccess for each + SingleObserver that subscribes to the current Single.
+
+
doOnTerminate(Action) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that calls the given onTerminate Action just before this Completable + completes normally or with an exception.
+
+
doOnTerminate(Action) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Calls the given Action when the current Flowable completes normally or with an error before those signals + are forwarded to the downstream.
+
+
doOnTerminate(Action) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe instance that calls the given onTerminate callback + just before this Maybe completes normally or with an exception.
+
+
doOnTerminate(Action) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable so that it invokes an action when the current Observable calls onComplete or + onError.
+
+
doOnTerminate(Action) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single instance that calls the given onTerminate callback + just before this Single completes normally or with an exception.
+
+
+ + + +

E

+
+
elementAt(long) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Maybe that emits the single item at a specified index in a sequence of emissions from + this Flowable or completes if this Flowable sequence has fewer elements than index.
+
+
elementAt(long, T) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits the item found at a specified index in a sequence of emissions from + this Flowable, or a default item if that index is out of range.
+
+
elementAt(long) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Maybe that emits the single item at a specified index in a sequence of emissions from + the current Observable or completes if the current Observable signals fewer elements than index.
+
+
elementAt(long, T) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits the item found at a specified index in a sequence of emissions from + the current Observable, or a default item if that index is out of range.
+
+
elementAtOrError(long) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits the item found at a specified index in a sequence of emissions from + this Flowable or signals a NoSuchElementException if this Flowable has fewer elements than index.
+
+
elementAtOrError(long) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits the item found at a specified index in a sequence of emissions from the current Observable + or signals a NoSuchElementException if the current Observable signals fewer elements than index.
+
+
Emitter<T> - Interface in io.reactivex.rxjava3.core
+
+
Base interface for emitting signals in a push-fashion in various generator-like source + operators (create, generate).
+
+
empty() - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits no items to the Subscriber and immediately invokes its + onComplete method.
+
+
empty() - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a (singleton) Maybe instance that calls onComplete + immediately.
+
+
empty() - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits no items to the Observer and immediately invokes its + onComplete method.
+
+
empty() - Static method in interface io.reactivex.rxjava3.disposables.Disposable
+
+
Returns a new, non-disposed Disposable instance.
+
+
equals(Object) - Method in class io.reactivex.rxjava3.core.Notification
+
 
+
equals(Object) - Method in class io.reactivex.rxjava3.schedulers.Timed
+
 
+
error(Supplier<? extends Throwable>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Creates a Completable which calls the given error supplier for each subscriber + and emits its returned Throwable.
+
+
error(Throwable) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Creates a Completable instance that emits the given Throwable exception to subscribers.
+
+
error(Supplier<? extends Throwable>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that invokes a Subscriber's onError method when the + Subscriber subscribes to it.
+
+
error(Throwable) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that invokes a Subscriber's onError method when the + Subscriber subscribes to it.
+
+
error(Throwable) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that invokes a subscriber's onError method when the + subscriber subscribes to it.
+
+
error(Supplier<? extends Throwable>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that invokes a MaybeObserver's onError method when the + MaybeObserver subscribes to it.
+
+
error(Supplier<? extends Throwable>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that invokes an Observer's onError method when the + Observer subscribes to it.
+
+
error(Throwable) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that invokes an Observer's onError method when the + Observer subscribes to it.
+
+
error(Supplier<? extends Throwable>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Signals a Throwable returned by the callback function for each individual SingleObserver.
+
+
error(Throwable) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that invokes a subscriber's onError method when the + subscriber subscribes to it.
+
+
errors - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
The list of errors received.
+
+
Exceptions - Class in io.reactivex.rxjava3.exceptions
+
+
Utility class to help propagate checked exceptions and rethrow exceptions + designated as fatal.
+
+
Experimental - Annotation Type in io.reactivex.rxjava3.annotations
+
+
Indicates the feature is in experimental state: its existence, signature or behavior + might change without warning from one release to the next.
+
+
+ + + +

F

+
+
fail(String) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Fail with the given message and add the sequence of errors as suppressed ones.
+
+
filter(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Filters items emitted by the current Flowable by only emitting those that satisfy a specified predicate.
+
+
filter(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Filters the success item of the Maybe via a predicate function and emitting it if the predicate + returns true, completing otherwise.
+
+
filter(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Filters items emitted by the current Observable by only emitting those that satisfy a specified Predicate.
+
+
filter(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Filters the success item of the Single via a predicate function and emitting it if the predicate + returns true, completing otherwise.
+
+
filter(Predicate<? super T>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Filters the source values on each 'rail'.
+
+
filter(Predicate<? super T>, ParallelFailureHandling) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Filters the source values on each 'rail' and + handles errors based on the given ParallelFailureHandling enumeration value.
+
+
filter(Predicate<? super T>, BiFunction<? super Long, ? super Throwable, ParallelFailureHandling>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Filters the source values on each 'rail' and + handles errors based on the returned value by the handler function.
+
+
first(T) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits only the very first item emitted by this Flowable, or a default + item if this Flowable completes without emitting anything.
+
+
first(T) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits only the very first item emitted by the current Observable, or a default item + if the current Observable completes without emitting any items.
+
+
firstElement() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Maybe that emits only the very first item emitted by this Flowable or + completes if this Flowable is empty.
+
+
firstElement() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Maybe that emits only the very first item emitted by the current Observable, or + completes if the current Observable is empty.
+
+
firstOrError() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits only the very first item emitted by this Flowable or + signals a NoSuchElementException if this Flowable is empty.
+
+
firstOrError() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits only the very first item emitted by the current Observable or + signals a NoSuchElementException if the current Observable is empty.
+
+
firstOrErrorStage() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Signals the first upstream item or a NoSuchElementException if the upstream is empty via + a CompletionStage.
+
+
firstOrErrorStage() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Signals the first upstream item or a NoSuchElementException if the upstream is empty via + a CompletionStage.
+
+
firstStage(T) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Signals the first upstream item (or the default item if the upstream is empty) via + a CompletionStage.
+
+
firstStage(T) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Signals the first upstream item (or the default item if the upstream is empty) via + a CompletionStage.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items based on applying a function that you supply to each item emitted + by the current Flowable, where that function returns a Publisher, and then merging those resulting + Publishers and emitting the results of this merger.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends R>>, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items based on applying a function that you supply to each item emitted + by the current Flowable, where that function returns a Publisher, and then merging those resulting + Publishers and emitting the results of this merger.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items based on applying a function that you supply to each item emitted + by the current Flowable, where that function returns a Publisher, and then merging those resulting + Publishers and emitting the results of this merger, while limiting the maximum number of concurrent + subscriptions to these Publishers.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends R>>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items based on applying a function that you supply to each item emitted + by the current Flowable, where that function returns a Publisher, and then merging those resulting + Publishers and emitting the results of this merger, while limiting the maximum number of concurrent + subscriptions to these Publishers.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends R>>, boolean, int, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items based on applying a function that you supply to each item emitted + by the current Flowable, where that function returns a Publisher, and then merging those resulting + Publishers and emitting the results of this merger, while limiting the maximum number of concurrent + subscriptions to these Publishers.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends R>>, Function<? super Throwable, ? extends Publisher<? extends R>>, Supplier<? extends Publisher<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that applies a function to each item emitted or notification raised by the current + Flowable and then flattens the Publishers returned from these functions and emits the resulting items.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends R>>, Function<Throwable, ? extends Publisher<? extends R>>, Supplier<? extends Publisher<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that applies a function to each item emitted or notification raised by the current + Flowable and then flattens the Publishers returned from these functions and emits the resulting items, + while limiting the maximum number of concurrent subscriptions to these Publishers.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends U>>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified function to the pair of values emitted by the + current Flowable and a specified collection Publisher.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends U>>, BiFunction<? super T, ? super U, ? extends R>, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified function to the pair of values emitted by the + current Flowable and a specified inner Publisher.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends U>>, BiFunction<? super T, ? super U, ? extends R>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified function to the pair of values emitted by the + current Flowable and a specified collection Publisher, while limiting the maximum number of concurrent + subscriptions to these Publishers.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends U>>, BiFunction<? super T, ? super U, ? extends R>, boolean, int, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified function to the pair of values emitted by the + current Flowable and a specified collection Publisher, while limiting the maximum number of concurrent + subscriptions to these Publishers.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends U>>, BiFunction<? super T, ? super U, ? extends R>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified function to the pair of values emitted by the + current Flowable and a specified collection Publisher, while limiting the maximum number of concurrent + subscriptions to these Publishers.
+
+
flatMap(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that is based on applying a specified function to the item emitted by the current Maybe, + where that function returns a MaybeSource.
+
+
flatMap(Function<? super T, ? extends MaybeSource<? extends R>>, Function<? super Throwable, ? extends MaybeSource<? extends R>>, Supplier<? extends MaybeSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Maps the onSuccess, onError or onComplete signals of the current Maybe into a MaybeSource and emits that + MaybeSource's signals.
+
+
flatMap(Function<? super T, ? extends MaybeSource<? extends U>>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits the results of a specified function to the pair of values emitted by the + current Maybe and a specified mapped MaybeSource.
+
+
flatMap(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items based on applying a function that you supply to each item emitted + by the current Observable, where that function returns an ObservableSource, and then merging those returned + ObservableSources and emitting the results of this merger.
+
+
flatMap(Function<? super T, ? extends ObservableSource<? extends R>>, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items based on applying a function that you supply to each item emitted + by the current Observable, where that function returns an ObservableSource, and then merging those returned + ObservableSources and emitting the results of this merger.
+
+
flatMap(Function<? super T, ? extends ObservableSource<? extends R>>, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items based on applying a function that you supply to each item emitted + by the current Observable, where that function returns an ObservableSource, and then merging those returned + ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent + subscriptions to these ObservableSources.
+
+
flatMap(Function<? super T, ? extends ObservableSource<? extends R>>, boolean, int, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items based on applying a function that you supply to each item emitted + by the current Observable, where that function returns an ObservableSource, and then merging those returned + ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent + subscriptions to these ObservableSources.
+
+
flatMap(Function<? super T, ? extends ObservableSource<? extends R>>, Function<? super Throwable, ? extends ObservableSource<? extends R>>, Supplier<? extends ObservableSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that applies a function to each item emitted or notification raised by the current + Observable and then flattens the ObservableSources returned from these functions and emits the resulting items.
+
+
flatMap(Function<? super T, ? extends ObservableSource<? extends R>>, Function<Throwable, ? extends ObservableSource<? extends R>>, Supplier<? extends ObservableSource<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that applies a function to each item emitted or notification raised by the current + Observable and then flattens the ObservableSources returned from these functions and emits the resulting items, + while limiting the maximum number of concurrent subscriptions to these ObservableSources.
+
+
flatMap(Function<? super T, ? extends ObservableSource<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items based on applying a function that you supply to each item emitted + by the current Observable, where that function returns an ObservableSource, and then merging those returned + ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent + subscriptions to these ObservableSources.
+
+
flatMap(Function<? super T, ? extends ObservableSource<? extends U>>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified function to the pair of values emitted by the + current Observable and the mapped inner ObservableSource.
+
+
flatMap(Function<? super T, ? extends ObservableSource<? extends U>>, BiFunction<? super T, ? super U, ? extends R>, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified function to the pair of values emitted by the + current Observable and the mapped inner ObservableSource.
+
+
flatMap(Function<? super T, ? extends ObservableSource<? extends U>>, BiFunction<? super T, ? super U, ? extends R>, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified function to the pair of values emitted by the + current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent + subscriptions to these ObservableSources.
+
+
flatMap(Function<? super T, ? extends ObservableSource<? extends U>>, BiFunction<? super T, ? super U, ? extends R>, boolean, int, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified function to the pair of values emitted by the + current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent + subscriptions to these ObservableSources.
+
+
flatMap(Function<? super T, ? extends ObservableSource<? extends U>>, BiFunction<? super T, ? super U, ? extends R>, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified function to the pair of values emitted by the + current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent + subscriptions to these ObservableSources.
+
+
flatMap(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that is based on applying a specified function to the item emitted by the current Single, + where that function returns a SingleSource.
+
+
flatMap(Function<? super T, ? extends SingleSource<? extends U>>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that emits the results of a specified function to the pair of values emitted by the + current Single and a specified mapped SingleSource.
+
+
flatMap(Function<? super T, ? extends SingleSource<? extends R>>, Function<? super Throwable, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Maps the onSuccess or onError signals of the current Single into a SingleSource and emits that + SingleSource's signals.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends R>>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Generates and flattens Publishers on each 'rail'.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends R>>, boolean) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Generates and flattens Publishers on each 'rail', optionally delaying errors.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends R>>, boolean, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Generates and flattens Publishers on each 'rail', optionally delaying errors + and having a total number of simultaneous subscriptions to the inner Publishers.
+
+
flatMap(Function<? super T, ? extends Publisher<? extends R>>, boolean, int, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Generates and flattens Publishers on each 'rail', optionally delaying errors, + having a total number of simultaneous subscriptions to the inner Publishers + and using the given prefetch amount for the inner Publishers.
+
+
flatMapCompletable(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps each element of the upstream Flowable into CompletableSources, subscribes to them and + waits until the upstream and all CompletableSources complete.
+
+
flatMapCompletable(Function<? super T, ? extends CompletableSource>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps each element of the upstream Flowable into CompletableSources, subscribes to them and + waits until the upstream and all CompletableSources complete, optionally delaying all errors.
+
+
flatMapCompletable(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Completable that completes based on applying a specified function to the item emitted by the + current Maybe, where that function returns a Completable.
+
+
flatMapCompletable(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps each element of the current Observable into CompletableSources, subscribes to them and + waits until the upstream and all CompletableSources complete.
+
+
flatMapCompletable(Function<? super T, ? extends CompletableSource>, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps each element of the current Observable into CompletableSources, subscribes to them and + waits until the upstream and all CompletableSources complete, optionally delaying all errors.
+
+
flatMapCompletable(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Completable that completes based on applying a specified function to the item emitted by the + current Single, where that function returns a CompletableSource.
+
+
flatMapIterable(Function<? super T, ? extends Iterable<? extends U>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Merges Iterables generated by a mapper Function for each individual item emitted by + the current Flowable into a single Flowable sequence.
+
+
flatMapIterable(Function<? super T, ? extends Iterable<? extends U>>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Merges Iterables generated by a mapper Function for each individual item emitted by + the current Flowable into a single Flowable sequence.
+
+
flatMapIterable(Function<? super T, ? extends Iterable<? extends U>>, BiFunction<? super T, ? super U, ? extends V>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Merges Iterables generated by a mapper Function for each individual item emitted by + the current Flowable into a single Flowable sequence where the resulting items will + be the combination of the original item and each inner item of the respective Iterable as returned + by the resultSelector BiFunction.
+
+
flatMapIterable(Function<? super T, ? extends Iterable<? extends U>>, BiFunction<? super T, ? super U, ? extends V>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Merges Iterables generated by a mapper Function for each individual item emitted by + the current Flowable into a single Flowable sequence where the resulting items will + be the combination of the original item and each inner item of the respective Iterable as returned + by the resultSelector BiFunction.
+
+
flatMapIterable(Function<? super T, ? extends Iterable<? extends U>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Merges Iterables generated by a mapper Function for each individual item emitted by + the current Observable into a single Observable sequence.
+
+
flatMapIterable(Function<? super T, ? extends Iterable<? extends U>>, BiFunction<? super T, ? super U, ? extends V>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Merges Iterables generated by a mapper Function for each individual item emitted by + the current Observable into a single Observable sequence where the resulting items will + be the combination of the original item and each inner item of the respective Iterable as returned + by the resultSelector BiFunction.
+
+
flatMapIterable(Function<? super T, ? extends Iterable<? extends U>>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Returns a ParallelFlowable that merges each item emitted by the source on each rail with the values in an + Iterable corresponding to that item that is generated by a selector.
+
+
flatMapIterable(Function<? super T, ? extends Iterable<? extends U>>, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Returns a ParallelFlowable that merges each item emitted by the source ParallelFlowable with the values in an + Iterable corresponding to that item that is generated by a selector.
+
+
flatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps each element of the upstream Flowable into MaybeSources, subscribes to all of them + and merges their onSuccess values, in no particular order, into a single Flowable sequence.
+
+
flatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps each element of the upstream Flowable into MaybeSources, subscribes to at most + maxConcurrency MaybeSources at a time and merges their onSuccess values, + in no particular order, into a single Flowable sequence, optionally delaying all errors.
+
+
flatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps each element of the current Observable into MaybeSources, subscribes to all of them + and merges their onSuccess values, in no particular order, into a single Observable sequence.
+
+
flatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>>, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps each element of the current Observable into MaybeSources, subscribes to them + and merges their onSuccess values, in no particular order, into a single Observable sequence, + optionally delaying all errors.
+
+
flatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Maybe that is based on applying a specified function to the item emitted by the current Single, + where that function returns a MaybeSource.
+
+
flatMapObservable(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns an Observable that is based on applying a specified function to the item emitted by the current Maybe, + where that function returns an ObservableSource.
+
+
flatMapObservable(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns an Observable that is based on applying a specified function to the item emitted by the current Single, + where that function returns an ObservableSource.
+
+
flatMapPublisher(Function<? super T, ? extends Publisher<? extends R>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Flowable that emits items based on applying a specified function to the item emitted by the + current Maybe, where that function returns a Publisher.
+
+
flatMapPublisher(Function<? super T, ? extends Publisher<? extends R>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Flowable that emits items based on applying a specified function to the item emitted by the + current Single, where that function returns a Publisher.
+
+
flatMapSingle(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps each element of the upstream Flowable into SingleSources, subscribes to all of them + and merges their onSuccess values, in no particular order, into a single Flowable sequence.
+
+
flatMapSingle(Function<? super T, ? extends SingleSource<? extends R>>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps each element of the upstream Flowable into SingleSources, subscribes to at most + maxConcurrency SingleSources at a time and merges their onSuccess values, + in no particular order, into a single Flowable sequence, optionally delaying all errors.
+
+
flatMapSingle(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe based on applying a specified function to the item emitted by the + current Maybe, where that function returns a Single.
+
+
flatMapSingle(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps each element of the current Observable into SingleSources, subscribes to all of them + and merges their onSuccess values, in no particular order, into a single Observable sequence.
+
+
flatMapSingle(Function<? super T, ? extends SingleSource<? extends R>>, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps each element of the current Observable into SingleSources, subscribes to them + and merges their onSuccess values, in no particular order, into a single Observable sequence, + optionally delaying all errors.
+
+
flatMapStream(Function<? super T, ? extends Stream<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
+
+
flatMapStream(Function<? super T, ? extends Stream<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
+
+
flatMapStream(Function<? super T, ? extends Stream<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
+
+
flatMapStream(Function<? super T, ? extends Stream<? extends R>>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Maps each upstream item on each rail into a Stream and emits the Stream's items to the downstream in a sequential fashion.
+
+
flatMapStream(Function<? super T, ? extends Stream<? extends R>>, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Maps each upstream item of each rail into a Stream and emits the Stream's items to the downstream in a sequential fashion.
+
+
flattenAsFlowable(Function<? super T, ? extends Iterable<? extends U>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Maps the success value of the current Maybe into an Iterable and emits its items as a + Flowable sequence.
+
+
flattenAsFlowable(Function<? super T, ? extends Iterable<? extends U>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Maps the success value of the current Single into an Iterable and emits its items as a + Flowable sequence.
+
+
flattenAsObservable(Function<? super T, ? extends Iterable<? extends U>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Maps the success value of the current Maybe into an Iterable and emits its items as an + Observable sequence.
+
+
flattenAsObservable(Function<? super T, ? extends Iterable<? extends U>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Maps the success value of the current Single into an Iterable and emits its items as an + Observable sequence.
+
+
flattenStreamAsFlowable(Function<? super T, ? extends Stream<? extends R>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Maps the upstream succecss value into a Java Stream and emits its + items to the downstream consumer as a Flowable.
+
+
flattenStreamAsFlowable(Function<? super T, ? extends Stream<? extends R>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Maps the upstream succecss value into a Java Stream and emits its + items to the downstream consumer as a Flowable.
+
+
flattenStreamAsObservable(Function<? super T, ? extends Stream<? extends R>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Maps the upstream succecss value into a Java Stream and emits its + items to the downstream consumer as an Observable.
+
+
flattenStreamAsObservable(Function<? super T, ? extends Stream<? extends R>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Maps the upstream succecss value into a Java Stream and emits its + items to the downstream consumer as an Observable.
+
+
Flowable<T> - Class in io.reactivex.rxjava3.core
+
+
The Flowable class that implements the Reactive Streams Publisher + Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows.
+
+
Flowable() - Constructor for class io.reactivex.rxjava3.core.Flowable
+
 
+
FlowableConverter<T,R> - Interface in io.reactivex.rxjava3.core
+
+
Convenience interface and callback used by the Flowable.to(io.reactivex.rxjava3.core.FlowableConverter<T, ? extends R>) operator to turn a Flowable into another + value fluently.
+
+
FlowableEmitter<T> - Interface in io.reactivex.rxjava3.core
+
+
Abstraction over a Reactive Streams Subscriber that allows associating + a resource with it and exposes the current number of downstream + requested amount.
+
+
FlowableOnSubscribe<T> - Interface in io.reactivex.rxjava3.core
+
+
A functional interface that has a subscribe() method that receives + a FlowableEmitter instance that allows pushing + events in a backpressure-safe and cancellation-safe manner.
+
+
FlowableOperator<Downstream,Upstream> - Interface in io.reactivex.rxjava3.core
+
+
Interface to map/wrap a downstream Subscriber to an upstream Subscriber.
+
+
FlowableProcessor<T> - Class in io.reactivex.rxjava3.processors
+
+
Represents a Subscriber and a Flowable (Publisher) at the same time, allowing + multicasting events from a single source to multiple child Subscribers.
+
+
FlowableProcessor() - Constructor for class io.reactivex.rxjava3.processors.FlowableProcessor
+
 
+
FlowableSubscriber<T> - Interface in io.reactivex.rxjava3.core
+
+
Represents a Reactive-Streams inspired Subscriber that is RxJava 3 only + and weakens the Reactive Streams rules §1.3 + and §3.9 of the specification + for gaining performance.
+
+
FlowableTransformer<Upstream,Downstream> - Interface in io.reactivex.rxjava3.core
+
+
Interface to compose Flowables.
+
+
forEach(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the current Flowable and receives notifications for each element.
+
+
forEach(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Subscribes to the ObservableSource and calls a Consumer for each item of the current Observable + on its emission thread.
+
+
forEachWhile(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the current Flowable and receives notifications for each element until the + onNext Predicate returns false.
+
+
forEachWhile(Predicate<? super T>, Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the current Flowable and receives notifications for each element and error events until the + onNext Predicate returns false.
+
+
forEachWhile(Predicate<? super T>, Consumer<? super Throwable>, Action) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the current Flowable and receives notifications for each element and the terminal events until the + onNext Predicate returns false.
+
+
forEachWhile(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Subscribes to the ObservableSource and calls a Predicate for each item of the current Observable, + on its emission thread, until the predicate returns false.
+
+
forEachWhile(Predicate<? super T>, Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Subscribes to the ObservableSource and calls a Predicate for each item or a Consumer with the error + of the current Observable, on their original emission threads, until the predicate returns false.
+
+
forEachWhile(Predicate<? super T>, Consumer<? super Throwable>, Action) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Subscribes to the ObservableSource and calls a Predicate for each item, a Consumer with the error + or an Action upon completion of the current Observable, on their original emission threads, + until the predicate returns false.
+
+
from(Publisher<? extends T>) - Static method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Take a Publisher and prepare to consume it on multiple 'rails' (number of CPUs) + in a round-robin fashion.
+
+
from(Publisher<? extends T>, int) - Static method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Take a Publisher and prepare to consume it on parallelism number of 'rails' in a round-robin fashion.
+
+
from(Publisher<? extends T>, int, int) - Static method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Take a Publisher and prepare to consume it on parallelism number of 'rails' , + possibly ordered and round-robin fashion and use custom prefetch amount and queue + for dealing with the source Publisher's values.
+
+
from(Executor) - Static method in class io.reactivex.rxjava3.schedulers.Schedulers
+
+
Wraps an Executor into a new Scheduler instance and delegates schedule() + calls to it.
+
+
from(Executor, boolean) - Static method in class io.reactivex.rxjava3.schedulers.Schedulers
+
+
Wraps an Executor into a new Scheduler instance and delegates schedule() + calls to it.
+
+
from(Executor, boolean, boolean) - Static method in class io.reactivex.rxjava3.schedulers.Schedulers
+
+
Wraps an Executor into a new Scheduler instance and delegates schedule() + calls to it.
+
+
fromAction(Action) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that runs the given Action for each CompletableObserver and + emits either an exception or simply completes.
+
+
fromAction(Action) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable instance that runs the given Action for each Subscriber and + emits either its exception or simply completes.
+
+
fromAction(Action) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe instance that runs the given Action for each MaybeObserver and + emits either its exception or simply completes.
+
+
fromAction(Action) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable instance that runs the given Action for each Observer and + emits either its exception or simply completes.
+
+
fromAction(Action) - Static method in interface io.reactivex.rxjava3.disposables.Disposable
+
+
Construct a Disposable by wrapping a Action that is + executed exactly once when the Disposable is disposed.
+
+
fromArray(T...) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts an array into a Publisher that emits the items in the array.
+
+
fromArray(T...) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts an array into an ObservableSource that emits the items in the array.
+
+
fromArray(Publisher<T>...) - Static method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Wraps multiple Publishers into a ParallelFlowable which runs them + in parallel and unordered.
+
+
fromAutoCloseable(AutoCloseable) - Static method in interface io.reactivex.rxjava3.disposables.Disposable
+
+
Construct a Disposable by wrapping an AutoCloseable that is + closed exactly once when the Disposable is disposed.
+
+
fromCallable(Callable<?>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which when subscribed, executes the Callable function, ignores its + normal result and emits onError or onComplete only.
+
+
fromCallable(Callable<? extends T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that, when a Subscriber subscribes to it, invokes a function you specify and then + emits the value returned from that function.
+
+
fromCallable(Callable<? extends T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that invokes the given Callable for each individual MaybeObserver that + subscribes and emits the resulting non-null item via onSuccess while + considering a null result from the Callable as indication for valueless completion + via onComplete.
+
+
fromCallable(Callable<? extends T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then + emits the value returned from that function.
+
+
fromCallable(Callable<? extends T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that invokes the given Callable for each incoming SingleObserver + and emits its value or exception to them.
+
+
fromCompletable(CompletableSource) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Wraps a CompletableSource into a Flowable.
+
+
fromCompletable(CompletableSource) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Wraps a CompletableSource into a Maybe.
+
+
fromCompletable(CompletableSource) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Wraps a CompletableSource into an Observable.
+
+
fromCompletionStage(CompletionStage<?>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Signals completion (or error) when the CompletionStage terminates.
+
+
fromCompletionStage(CompletionStage<T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.
+
+
fromCompletionStage(CompletionStage<T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.
+
+
fromCompletionStage(CompletionStage<T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.
+
+
fromCompletionStage(CompletionStage<T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.
+
+
fromFuture(Future<?>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that reacts to the termination of the given Future in a blocking fashion.
+
+
fromFuture(Future<? extends T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts a Future into a Publisher.
+
+
fromFuture(Future<? extends T>, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts a Future into a Publisher, with a timeout on the Future.
+
+
fromFuture(Future<? extends T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Converts a Future into a Maybe, treating a null result as an indication of emptiness.
+
+
fromFuture(Future<? extends T>, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Converts a Future into a Maybe, with a timeout on the Future.
+
+
fromFuture(Future<? extends T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts a Future into an Observable.
+
+
fromFuture(Future<? extends T>, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts a Future into an Observable, with a timeout on the Future.
+
+
fromFuture(Future<? extends T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Converts a Future into a Single and awaits its outcome in a blocking fashion.
+
+
fromFuture(Future<? extends T>, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Converts a Future into a Single and awaits its outcome, or timeout, in a blocking fashion.
+
+
fromFuture(Future<?>) - Static method in interface io.reactivex.rxjava3.disposables.Disposable
+
+
Construct a Disposable by wrapping a Future that is + cancelled exactly once when the Disposable is disposed.
+
+
fromFuture(Future<?>, boolean) - Static method in interface io.reactivex.rxjava3.disposables.Disposable
+
+
Construct a Disposable by wrapping a Future that is + cancelled exactly once when the Disposable is disposed.
+
+
fromIterable(Iterable<? extends T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts an Iterable sequence into a Publisher that emits the items in the sequence.
+
+
fromIterable(Iterable<? extends T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts an Iterable sequence into an Observable that emits the items in the sequence.
+
+
fromMaybe(MaybeSource<T>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that when subscribed to, subscribes to the MaybeSource instance and + emits an onComplete event if the maybe emits onSuccess/onComplete or forwards any + onError events.
+
+
fromMaybe(MaybeSource<T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable instance that when subscribed to, subscribes to the MaybeSource instance and + emits onSuccess as a single item or forwards any onComplete or + onError signal.
+
+
fromMaybe(MaybeSource<T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable instance that when subscribed to, subscribes to the MaybeSource instance and + emits onSuccess as a single item or forwards any onComplete or + onError signal.
+
+
fromMaybe(MaybeSource<T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and + emits onSuccess as a single item, turns an onComplete into NoSuchElementException error signal or + forwards the onError signal.
+
+
fromMaybe(MaybeSource<T>, T) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and + emits onSuccess as a single item, emits the defaultItem for an onComplete signal or + forwards the onError signal.
+
+
fromObservable(ObservableSource<T>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that subscribes to the given ObservableSource, ignores all values and + emits only the terminal event.
+
+
fromObservable(ObservableSource<T>, BackpressureStrategy) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts the given ObservableSource into a Flowable by applying the specified backpressure strategy.
+
+
fromObservable(ObservableSource<T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Wraps an ObservableSource into a Maybe and emits the very first item + or completes if the source is empty.
+
+
fromObservable(ObservableSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Wraps a specific ObservableSource into a Single and signals its single element or error.
+
+
fromOptional(Optional<T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts the existing value of the provided optional into a Flowable.just(Object) + or an empty optional into an Flowable.empty() Flowable instance.
+
+
fromOptional(Optional<T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Converts the existing value of the provided optional into a Maybe.just(Object) + or an empty optional into an Maybe.empty() Maybe instance.
+
+
fromOptional(Optional<T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts the existing value of the provided optional into a Observable.just(Object) + or an empty optional into an Observable.empty() Observable instance.
+
+
fromPublisher(Publisher<T>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that subscribes to the given Publisher, ignores all values and + emits only the terminal event.
+
+
fromPublisher(Publisher<? extends T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts an arbitrary Reactive Streams Publisher into a Flowable if not already a + Flowable.
+
+
fromPublisher(Publisher<T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Wraps a Publisher into a Maybe and emits the very first item + or completes if the source is empty.
+
+
fromPublisher(Publisher<? extends T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts an arbitrary Reactive Streams Publisher into an Observable.
+
+
fromPublisher(Publisher<? extends T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Wraps a specific Publisher into a Single and signals its single element or error.
+
+
fromRunnable(Runnable) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that runs the given Runnable for each CompletableObserver and + emits either its unchecked exception or simply completes.
+
+
fromRunnable(Runnable) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable instance that runs the given Runnable for each Subscriber and + emits either its unchecked exception or simply completes.
+
+
fromRunnable(Runnable) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe instance that runs the given Runnable for each MaybeObserver and + emits either its unchecked exception or simply completes.
+
+
fromRunnable(Runnable) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable instance that runs the given Runnable for each Observer and + emits either its unchecked exception or simply completes.
+
+
fromRunnable(Runnable) - Static method in interface io.reactivex.rxjava3.disposables.Disposable
+
+
Construct a Disposable by wrapping a Runnable that is + executed exactly once when the Disposable is disposed.
+
+
fromSingle(SingleSource<T>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that when subscribed to, subscribes to the SingleSource instance and + emits a completion event if the single emits onSuccess or forwards any onError events.
+
+
fromSingle(SingleSource<T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable instance that when subscribed to, subscribes to the SingleSource instance and + emits onSuccess as a single item or forwards the onError signal.
+
+
fromSingle(SingleSource<T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Wraps a SingleSource into a Maybe.
+
+
fromSingle(SingleSource<T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable instance that when subscribed to, subscribes to the SingleSource instance and + emits onSuccess as a single item or forwards the onError signal.
+
+
fromStream(Stream<T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts a Stream into a finite Flowable and emits its items in the sequence.
+
+
fromStream(Stream<T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts a Stream into a finite Observable and emits its items in the sequence.
+
+
fromSubscription(Subscription) - Static method in interface io.reactivex.rxjava3.disposables.Disposable
+
+
Construct a Disposable by wrapping a Subscription that is + cancelled exactly once when the Disposable is disposed.
+
+
fromSupplier(Supplier<?>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which when subscribed, executes the Supplier function, ignores its + normal result and emits onError or onComplete only.
+
+
fromSupplier(Supplier<? extends T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that, when a Subscriber subscribes to it, invokes a supplier function you specify and then + emits the value returned from that function.
+
+
fromSupplier(Supplier<? extends T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that invokes the given Supplier for each individual MaybeObserver that + subscribes and emits the resulting non-null item via onSuccess while + considering a null result from the Supplier as indication for valueless completion + via onComplete.
+
+
fromSupplier(Supplier<? extends T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that, when an observer subscribes to it, invokes a supplier function you specify and then + emits the value returned from that function.
+
+
fromSupplier(Supplier<? extends T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that invokes passed supplier and emits its result + for each individual SingleObserver that subscribes.
+
+
Function<T,R> - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface that takes a value and returns another value, possibly with a + different type and allows throwing a checked exception.
+
+
Function3<T1,T2,T3,R> - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that computes a value based on multiple input values.
+
+
Function4<T1,T2,T3,T4,R> - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that computes a value based on multiple input values.
+
+
Function5<T1,T2,T3,T4,T5,R> - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that computes a value based on multiple input values.
+
+
Function6<T1,T2,T3,T4,T5,T6,R> - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that computes a value based on multiple input values.
+
+
Function7<T1,T2,T3,T4,T5,T6,T7,R> - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that computes a value based on multiple input values.
+
+
Function8<T1,T2,T3,T4,T5,T6,T7,T8,R> - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that computes a value based on multiple input values.
+
+
Function9<T1,T2,T3,T4,T5,T6,T7,T8,T9,R> - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that computes a value based on multiple input values.
+
+
+ + + +

G

+
+
generate(Consumer<Emitter<T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a cold, synchronous, stateless and backpressure-aware generator of values.
+
+
generate(Supplier<S>, BiConsumer<S, Emitter<T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a cold, synchronous, stateful and backpressure-aware generator of values.
+
+
generate(Supplier<S>, BiConsumer<S, Emitter<T>>, Consumer<? super S>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a cold, synchronous, stateful and backpressure-aware generator of values.
+
+
generate(Supplier<S>, BiFunction<S, Emitter<T>, S>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a cold, synchronous, stateful and backpressure-aware generator of values.
+
+
generate(Supplier<S>, BiFunction<S, Emitter<T>, S>, Consumer<? super S>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a cold, synchronous, stateful and backpressure-aware generator of values.
+
+
generate(Consumer<Emitter<T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a cold, synchronous and stateless generator of values.
+
+
generate(Supplier<S>, BiConsumer<S, Emitter<T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a cold, synchronous and stateful generator of values.
+
+
generate(Supplier<S>, BiConsumer<S, Emitter<T>>, Consumer<? super S>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a cold, synchronous and stateful generator of values.
+
+
generate(Supplier<S>, BiFunction<S, Emitter<T>, S>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a cold, synchronous and stateful generator of values.
+
+
generate(Supplier<S>, BiFunction<S, Emitter<T>, S>, Consumer<? super S>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a cold, synchronous and stateful generator of values.
+
+
get() - Method in class io.reactivex.rxjava3.disposables.SerialDisposable
+
+
Returns the currently contained Disposable or null if this container is empty.
+
+
get() - Method in interface io.reactivex.rxjava3.functions.Supplier
+
+
Produces a value or throws an exception.
+
+
get() - Method in interface io.reactivex.rxjava3.operators.ScalarSupplier
+
 
+
getAsBoolean() - Method in interface io.reactivex.rxjava3.functions.BooleanSupplier
+
+
Returns a boolean value.
+
+
getCause() - Method in exception io.reactivex.rxjava3.exceptions.CompositeException
+
 
+
getComputationSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getError() - Method in class io.reactivex.rxjava3.core.Notification
+
+
Returns the container Throwable error if this notification is an onError + signal, null otherwise.
+
+
getErrorHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the a hook consumer.
+
+
getExceptions() - Method in exception io.reactivex.rxjava3.exceptions.CompositeException
+
+
Retrieves the list of exceptions that make up the CompositeException.
+
+
getInitComputationSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getInitIoSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getInitNewThreadSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getInitSingleSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getIoSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getKey() - Method in class io.reactivex.rxjava3.flowables.GroupedFlowable
+
+
Returns the key that identifies the group of items emitted by this GroupedFlowable.
+
+
getKey() - Method in class io.reactivex.rxjava3.observables.GroupedObservable
+
+
Returns the key that identifies the group of items emitted by this GroupedObservable.
+
+
getMessage() - Method in exception io.reactivex.rxjava3.exceptions.CompositeException
+
 
+
getNewThreadSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getOnBeforeBlocking() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current blocking handler or null if no custom handler + is set.
+
+
getOnCompletableAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getOnCompletableSubscribe() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getOnConnectableFlowableAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getOnConnectableObservableAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getOnFlowableAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getOnFlowableSubscribe() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getOnMaybeAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getOnMaybeSubscribe() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getOnObservableAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getOnObservableSubscribe() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getOnParallelAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getOnParallelSubscribe() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getOnSingleAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getOnSingleSubscribe() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getScheduleHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getSingleSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns the current hook function.
+
+
getThrowable() - Method in class io.reactivex.rxjava3.processors.AsyncProcessor
+
 
+
getThrowable() - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor
+
 
+
getThrowable() - Method in class io.reactivex.rxjava3.processors.FlowableProcessor
+
+
Returns the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor + hasn't terminated yet.
+
+
getThrowable() - Method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
 
+
getThrowable() - Method in class io.reactivex.rxjava3.processors.PublishProcessor
+
 
+
getThrowable() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
 
+
getThrowable() - Method in class io.reactivex.rxjava3.processors.UnicastProcessor
+
 
+
getThrowable() - Method in class io.reactivex.rxjava3.subjects.AsyncSubject
+
 
+
getThrowable() - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject
+
 
+
getThrowable() - Method in class io.reactivex.rxjava3.subjects.CompletableSubject
+
+
Returns the terminal error if this CompletableSubject has been terminated with an error, null otherwise.
+
+
getThrowable() - Method in class io.reactivex.rxjava3.subjects.MaybeSubject
+
+
Returns the terminal error if this MaybeSubject has been terminated with an error, null otherwise.
+
+
getThrowable() - Method in class io.reactivex.rxjava3.subjects.PublishSubject
+
 
+
getThrowable() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
 
+
getThrowable() - Method in class io.reactivex.rxjava3.subjects.SingleSubject
+
+
Returns the terminal error if this SingleSubject has been terminated with an error, null otherwise.
+
+
getThrowable() - Method in class io.reactivex.rxjava3.subjects.Subject
+
+
Returns the error that caused the Subject to terminate or null if the Subject + hasn't terminated yet.
+
+
getThrowable() - Method in class io.reactivex.rxjava3.subjects.UnicastSubject
+
 
+
getValue() - Method in class io.reactivex.rxjava3.core.Notification
+
+
Returns the contained value if this notification is an onNext + signal, null otherwise.
+
+
getValue() - Method in class io.reactivex.rxjava3.processors.AsyncProcessor
+
+
Returns a single value this processor currently has or null if no such value exists.
+
+
getValue() - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor
+
+
Returns a single value the BehaviorProcessor currently has or null if no such value exists.
+
+
getValue() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
+
Returns the latest value this processor has or null if no such value exists.
+
+
getValue() - Method in class io.reactivex.rxjava3.subjects.AsyncSubject
+
+
Returns a single value the Subject currently has or null if no such value exists.
+
+
getValue() - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject
+
+
Returns a single value the Subject currently has or null if no such value exists.
+
+
getValue() - Method in class io.reactivex.rxjava3.subjects.MaybeSubject
+
+
Returns the success value if this MaybeSubject was terminated with a success value.
+
+
getValue() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
+
Returns a single value the Subject currently has or null if no such value exists.
+
+
getValue() - Method in class io.reactivex.rxjava3.subjects.SingleSubject
+
+
Returns the success value if this SingleSubject was terminated with a success value.
+
+
getValues() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
+
Returns an Object array containing snapshot all values of this processor.
+
+
getValues(T[]) - Method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
+
Returns a typed array containing a snapshot of all values of this processor.
+
+
getValues() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
+
Returns an Object array containing snapshot all values of the Subject.
+
+
getValues(T[]) - Method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
+
Returns a typed array containing a snapshot of all values of the Subject.
+
+
getWrappedRunnable() - Method in interface io.reactivex.rxjava3.schedulers.SchedulerRunnableIntrospection
+
+
Returns the wrapped action.
+
+
groupBy(Function<? super T, ? extends K>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Groups the items emitted by the current Flowable according to a specified criterion, and emits these + grouped items as GroupedFlowables.
+
+
groupBy(Function<? super T, ? extends K>, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Groups the items emitted by the current Flowable according to a specified criterion, and emits these + grouped items as GroupedFlowables.
+
+
groupBy(Function<? super T, ? extends K>, Function<? super T, ? extends V>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Groups the items emitted by the current Flowable according to a specified criterion, and emits these + grouped items as GroupedFlowables.
+
+
groupBy(Function<? super T, ? extends K>, Function<? super T, ? extends V>, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Groups the items emitted by the current Flowable according to a specified criterion, and emits these + grouped items as GroupedFlowables.
+
+
groupBy(Function<? super T, ? extends K>, Function<? super T, ? extends V>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Groups the items emitted by the current Flowable according to a specified criterion, and emits these + grouped items as GroupedFlowables.
+
+
groupBy(Function<? super T, ? extends K>, Function<? super T, ? extends V>, boolean, int, Function<? super Consumer<Object>, ? extends Map<K, Object>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Groups the items emitted by the current Flowable according to a specified criterion, and emits these + grouped items as GroupedFlowables.
+
+
groupBy(Function<? super T, ? extends K>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Groups the items emitted by the current Observable according to a specified criterion, and emits these + grouped items as GroupedObservables.
+
+
groupBy(Function<? super T, ? extends K>, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Groups the items emitted by the current Observable according to a specified criterion, and emits these + grouped items as GroupedObservables.
+
+
groupBy(Function<? super T, ? extends K>, Function<? super T, ? extends V>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Groups the items emitted by the current Observable according to a specified criterion, and emits these + grouped items as GroupedObservables.
+
+
groupBy(Function<? super T, ? extends K>, Function<? super T, ? extends V>, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Groups the items emitted by the current Observable according to a specified criterion, and emits these + grouped items as GroupedObservables.
+
+
groupBy(Function<? super T, ? extends K>, Function<? super T, ? extends V>, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Groups the items emitted by the current Observable according to a specified criterion, and emits these + grouped items as GroupedObservables.
+
+
GroupedFlowable<K,T> - Class in io.reactivex.rxjava3.flowables
+
+
A Flowable that has been grouped by key, the value of which can be obtained with GroupedFlowable.getKey().
+
+
GroupedFlowable(K) - Constructor for class io.reactivex.rxjava3.flowables.GroupedFlowable
+
+
Constructs a GroupedFlowable with the given key.
+
+
GroupedObservable<K,T> - Class in io.reactivex.rxjava3.observables
+
+
An Observable that has been grouped by key, the value of which can be obtained with GroupedObservable.getKey().
+
+
GroupedObservable(K) - Constructor for class io.reactivex.rxjava3.observables.GroupedObservable
+
+
Constructs a GroupedObservable with the given key.
+
+
groupJoin(Publisher<? extends TRight>, Function<? super T, ? extends Publisher<TLeftEnd>>, Function<? super TRight, ? extends Publisher<TRightEnd>>, BiFunction<? super T, ? super Flowable<TRight>, ? extends R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that correlates two Publishers when they overlap in time and groups the results.
+
+
groupJoin(ObservableSource<? extends TRight>, Function<? super T, ? extends ObservableSource<TLeftEnd>>, Function<? super TRight, ? extends ObservableSource<TRightEnd>>, BiFunction<? super T, ? super Observable<TRight>, ? extends R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that correlates two ObservableSources when they overlap in time and groups the results.
+
+
+ + + +

H

+
+
hasComplete() - Method in class io.reactivex.rxjava3.processors.AsyncProcessor
+
 
+
hasComplete() - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor
+
 
+
hasComplete() - Method in class io.reactivex.rxjava3.processors.FlowableProcessor
+
+
Returns true if the FlowableProcessor has reached a terminal state through a complete event.
+
+
hasComplete() - Method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
 
+
hasComplete() - Method in class io.reactivex.rxjava3.processors.PublishProcessor
+
 
+
hasComplete() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
 
+
hasComplete() - Method in class io.reactivex.rxjava3.processors.UnicastProcessor
+
 
+
hasComplete() - Method in class io.reactivex.rxjava3.subjects.AsyncSubject
+
 
+
hasComplete() - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject
+
 
+
hasComplete() - Method in class io.reactivex.rxjava3.subjects.CompletableSubject
+
+
Returns true if this CompletableSubject has been completed.
+
+
hasComplete() - Method in class io.reactivex.rxjava3.subjects.MaybeSubject
+
+
Returns true if this MaybeSubject has been completed.
+
+
hasComplete() - Method in class io.reactivex.rxjava3.subjects.PublishSubject
+
 
+
hasComplete() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
 
+
hasComplete() - Method in class io.reactivex.rxjava3.subjects.Subject
+
+
Returns true if the subject has reached a terminal state through a complete event.
+
+
hasComplete() - Method in class io.reactivex.rxjava3.subjects.UnicastSubject
+
 
+
hasCustomOnError() - Method in interface io.reactivex.rxjava3.observers.LambdaConsumerIntrospection
+
+
Returns true or false if a custom onError consumer has been provided.
+
+
hashCode() - Method in class io.reactivex.rxjava3.core.Notification
+
 
+
hashCode() - Method in class io.reactivex.rxjava3.schedulers.Timed
+
 
+
hasObservers() - Method in class io.reactivex.rxjava3.subjects.AsyncSubject
+
 
+
hasObservers() - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject
+
 
+
hasObservers() - Method in class io.reactivex.rxjava3.subjects.CompletableSubject
+
+
Returns true if this CompletableSubject has observers.
+
+
hasObservers() - Method in class io.reactivex.rxjava3.subjects.MaybeSubject
+
+
Returns true if this MaybeSubject has observers.
+
+
hasObservers() - Method in class io.reactivex.rxjava3.subjects.PublishSubject
+
 
+
hasObservers() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
 
+
hasObservers() - Method in class io.reactivex.rxjava3.subjects.SingleSubject
+
+
Returns true if this SingleSubject has observers.
+
+
hasObservers() - Method in class io.reactivex.rxjava3.subjects.Subject
+
+
Returns true if the subject has any Observers.
+
+
hasObservers() - Method in class io.reactivex.rxjava3.subjects.UnicastSubject
+
 
+
hasSubscribers() - Method in class io.reactivex.rxjava3.processors.AsyncProcessor
+
 
+
hasSubscribers() - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor
+
 
+
hasSubscribers() - Method in class io.reactivex.rxjava3.processors.FlowableProcessor
+
+
Returns true if the FlowableProcessor has subscribers.
+
+
hasSubscribers() - Method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
 
+
hasSubscribers() - Method in class io.reactivex.rxjava3.processors.PublishProcessor
+
 
+
hasSubscribers() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
 
+
hasSubscribers() - Method in class io.reactivex.rxjava3.processors.UnicastProcessor
+
 
+
hasSubscription() - Method in class io.reactivex.rxjava3.observers.TestObserver
+
+
Returns true if this TestObserver received a subscription.
+
+
hasSubscription() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
+
Returns true if this TestSubscriber received a Subscription via TestSubscriber.onSubscribe(Subscription).
+
+
hasThrowable() - Method in class io.reactivex.rxjava3.processors.AsyncProcessor
+
 
+
hasThrowable() - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor
+
 
+
hasThrowable() - Method in class io.reactivex.rxjava3.processors.FlowableProcessor
+
+
Returns true if the FlowableProcessor has reached a terminal state through an error event.
+
+
hasThrowable() - Method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
 
+
hasThrowable() - Method in class io.reactivex.rxjava3.processors.PublishProcessor
+
 
+
hasThrowable() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
 
+
hasThrowable() - Method in class io.reactivex.rxjava3.processors.UnicastProcessor
+
 
+
hasThrowable() - Method in class io.reactivex.rxjava3.subjects.AsyncSubject
+
 
+
hasThrowable() - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject
+
 
+
hasThrowable() - Method in class io.reactivex.rxjava3.subjects.CompletableSubject
+
+
Returns true if this CompletableSubject has been terminated with an error.
+
+
hasThrowable() - Method in class io.reactivex.rxjava3.subjects.MaybeSubject
+
+
Returns true if this MaybeSubject has been terminated with an error.
+
+
hasThrowable() - Method in class io.reactivex.rxjava3.subjects.PublishSubject
+
 
+
hasThrowable() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
 
+
hasThrowable() - Method in class io.reactivex.rxjava3.subjects.SingleSubject
+
+
Returns true if this SingleSubject has been terminated with an error.
+
+
hasThrowable() - Method in class io.reactivex.rxjava3.subjects.Subject
+
+
Returns true if the subject has reached a terminal state through an error event.
+
+
hasThrowable() - Method in class io.reactivex.rxjava3.subjects.UnicastSubject
+
 
+
hasValue() - Method in class io.reactivex.rxjava3.processors.AsyncProcessor
+
+
Returns true if this processor has any value.
+
+
hasValue() - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor
+
+
Returns true if the BehaviorProcessor has any value.
+
+
hasValue() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
+
Returns true if this processor has any value.
+
+
hasValue() - Method in class io.reactivex.rxjava3.subjects.AsyncSubject
+
+
Returns true if the subject has any value.
+
+
hasValue() - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject
+
+
Returns true if the subject has any value.
+
+
hasValue() - Method in class io.reactivex.rxjava3.subjects.MaybeSubject
+
+
Returns true if this MaybeSubject was terminated with a success value.
+
+
hasValue() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
+
Returns true if the subject has any value.
+
+
hasValue() - Method in class io.reactivex.rxjava3.subjects.SingleSubject
+
+
Returns true if this SingleSubject was terminated with a success value.
+
+
hide() - Method in class io.reactivex.rxjava3.core.Completable
+
+
Hides the identity of this Completable and its Disposable.
+
+
hide() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Hides the identity of this Flowable and its Subscription.
+
+
hide() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Hides the identity of this Maybe and its Disposable.
+
+
hide() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Hides the identity of the current Observable and its Disposable.
+
+
hide() - Method in class io.reactivex.rxjava3.core.Single
+
+
Hides the identity of the current Single, including the Disposable that is sent + to the downstream via onSubscribe().
+
+
+ + + +

I

+
+
ignoreElement() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Completable that ignores the item emitted by the current Maybe and only calls onComplete or onError.
+
+
ignoreElement() - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Completable that ignores the success value of this Single + and signals onComplete instead.
+
+
ignoreElements() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Ignores all items emitted by the current Flowable and only calls onComplete or onError.
+
+
ignoreElements() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Ignores all items emitted by the current Observable and only calls onComplete or onError.
+
+
initComputationScheduler(Supplier<Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
initIoScheduler(Supplier<Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
initNewThreadScheduler(Supplier<Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
initSingleScheduler(Supplier<Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
interval(long, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers + after each period of time thereafter.
+
+
interval(long, long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers + after each period of time thereafter, on a specified Scheduler.
+
+
interval(long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits a sequential number every specified interval of time.
+
+
interval(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits a sequential number every specified interval of time, on a + specified Scheduler.
+
+
interval(long, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers + after each period of time thereafter.
+
+
interval(long, long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers + after each period of time thereafter, on a specified Scheduler.
+
+
interval(long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits a sequential number every specified interval of time.
+
+
interval(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits a sequential number every specified interval of time, on a + specified Scheduler.
+
+
intervalRange(long, long, long, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Signals a range of long values, the first after some initial delay and the rest periodically after.
+
+
intervalRange(long, long, long, long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Signals a range of long values, the first after some initial delay and the rest periodically after.
+
+
intervalRange(long, long, long, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Signals a range of long values, the first after some initial delay and the rest periodically after.
+
+
intervalRange(long, long, long, long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Signals a range of long values, the first after some initial delay and the rest periodically after.
+
+
IntFunction<T> - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that takes a primitive value and return value of type T.
+
+
IO - Static variable in annotation type io.reactivex.rxjava3.annotations.SchedulerSupport
+
+
The operator/class runs on RxJava's I/O scheduler or takes + timing information from it.
+
+
io() - Static method in class io.reactivex.rxjava3.schedulers.Schedulers
+
+
Returns a default, shared Scheduler instance intended for IO-bound work.
+
+
io.reactivex.rxjava3.annotations - package io.reactivex.rxjava3.annotations
+
+
Annotations for indicating operator behavior, API stability + (@Experimental and @Beta) and + nullability indicators (Nullable and NonNull).
+
+
io.reactivex.rxjava3.core - package io.reactivex.rxjava3.core
+
+
Base reactive classes: Flowable, Observable, + Single, Maybe and + Completable; base reactive consumers; + other common base interfaces.
+
+
io.reactivex.rxjava3.disposables - package io.reactivex.rxjava3.disposables
+
+
Default implementations for Disposable-based resource management + (Disposable container types) and utility classes to construct + Disposables from callbacks and other types.
+
+
io.reactivex.rxjava3.exceptions - package io.reactivex.rxjava3.exceptions
+
+
Exception handling utilities (Exceptions), + composite exception container (CompositeException) and + various lifecycle-related (UndeliverableException) + and behavior-violation exception types (OnErrorNotImplementedException, + MissingBackpressureException).
+
+
io.reactivex.rxjava3.flowables - package io.reactivex.rxjava3.flowables
+
+
Classes supporting the Flowable base reactive class: + ConnectableFlowable and + GroupedFlowable.
+
+
io.reactivex.rxjava3.functions - package io.reactivex.rxjava3.functions
+
+
Functional interfaces of functions and actions of arity 0 to 9 and related + utility classes.
+
+
io.reactivex.rxjava3.observables - package io.reactivex.rxjava3.observables
+
+
Classes supporting the Observable base reactive class: + ConnectableObservable and + GroupedObservable.
+
+
io.reactivex.rxjava3.observers - package io.reactivex.rxjava3.observers
+
+
Default wrappers and implementations for observer-based consumer classes and interfaces, + including disposable and resource-tracking variants and + the TestObserver that allows unit testing + Observable-, Single-, + Maybe- and Completable-based flows.
+
+
io.reactivex.rxjava3.operators - package io.reactivex.rxjava3.operators
+
+
Classes and interfaces for writing advanced operators within and outside RxJava.
+
+
io.reactivex.rxjava3.parallel - package io.reactivex.rxjava3.parallel
+
+
Contains the base type ParallelFlowable, + a sub-DSL for working with Flowable sequences in parallel.
+
+
io.reactivex.rxjava3.plugins - package io.reactivex.rxjava3.plugins
+
+
Contains the central plugin handler RxJavaPlugins + class to hook into the lifecycle of the base reactive types and schedulers.
+
+
io.reactivex.rxjava3.processors - package io.reactivex.rxjava3.processors
+
+
Classes representing so-called hot backpressure-aware sources, aka processors, + that implement the FlowableProcessor class, + the Reactive Streams Processor interface + to allow forms of multicasting events to one or more subscribers as well as consuming another + Reactive Streams Publisher.
+
+
io.reactivex.rxjava3.schedulers - package io.reactivex.rxjava3.schedulers
+
+
Contains notably the factory class of Schedulers providing methods for + retrieving the standard scheduler instances, the TestScheduler for testing flows + with scheduling in a controlled manner and the class Timed that can hold + a value and a timestamp associated with it.
+
+
io.reactivex.rxjava3.subjects - package io.reactivex.rxjava3.subjects
+
+
Classes representing so-called hot sources, aka subjects, that implement a base reactive class and + the respective consumer type at once to allow forms of multicasting events to multiple + consumers as well as consuming another base reactive type of their kind.
+
+
io.reactivex.rxjava3.subscribers - package io.reactivex.rxjava3.subscribers
+
+
Default wrappers and implementations for Subscriber-based consumer classes and interfaces, + including disposable (DisposableSubscriber) and resource-tracking + (ResourceSubscriber) + variants and the TestSubscriber that allows unit testing + Flowable-based flows.
+
+
isCancelled() - Method in interface io.reactivex.rxjava3.core.FlowableEmitter
+
+
Returns true if the downstream cancelled the sequence or the + emitter was terminated via Emitter.onError(Throwable), Emitter.onComplete() or a + successful FlowableEmitter.tryOnError(Throwable).
+
+
isCancelled() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
+
Returns true if this TestSubscriber has been cancelled.
+
+
isDisposed() - Method in interface io.reactivex.rxjava3.core.CompletableEmitter
+
+
Returns true if the downstream disposed the sequence or the + emitter was terminated via CompletableEmitter.onError(Throwable), + CompletableEmitter.onComplete() or a successful CompletableEmitter.tryOnError(Throwable).
+
+
isDisposed() - Method in interface io.reactivex.rxjava3.core.MaybeEmitter
+
+
Returns true if the downstream disposed the sequence or the + emitter was terminated via MaybeEmitter.onSuccess(Object), MaybeEmitter.onError(Throwable), + MaybeEmitter.onComplete() or a + successful MaybeEmitter.tryOnError(Throwable).
+
+
isDisposed() - Method in interface io.reactivex.rxjava3.core.ObservableEmitter
+
+
Returns true if the downstream disposed the sequence or the + emitter was terminated via Emitter.onError(Throwable), Emitter.onComplete() or a + successful ObservableEmitter.tryOnError(Throwable).
+
+
isDisposed() - Method in interface io.reactivex.rxjava3.core.SingleEmitter
+
+
Returns true if the downstream disposed the sequence or the + emitter was terminated via SingleEmitter.onSuccess(Object), SingleEmitter.onError(Throwable), + or a successful SingleEmitter.tryOnError(Throwable).
+
+
isDisposed() - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable
+
 
+
isDisposed() - Method in interface io.reactivex.rxjava3.disposables.Disposable
+
+
Returns true if this resource has been disposed.
+
+
isDisposed() - Method in class io.reactivex.rxjava3.disposables.SerialDisposable
+
 
+
isDisposed() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Returns true if this test consumer was cancelled/disposed.
+
+
isDisposed() - Method in class io.reactivex.rxjava3.observers.DisposableCompletableObserver
+
 
+
isDisposed() - Method in class io.reactivex.rxjava3.observers.DisposableMaybeObserver
+
 
+
isDisposed() - Method in class io.reactivex.rxjava3.observers.DisposableObserver
+
 
+
isDisposed() - Method in class io.reactivex.rxjava3.observers.DisposableSingleObserver
+
 
+
isDisposed() - Method in class io.reactivex.rxjava3.observers.ResourceCompletableObserver
+
+
Returns true if this ResourceCompletableObserver has been disposed/cancelled.
+
+
isDisposed() - Method in class io.reactivex.rxjava3.observers.ResourceMaybeObserver
+
+
Returns true if this ResourceMaybeObserver has been disposed/cancelled.
+
+
isDisposed() - Method in class io.reactivex.rxjava3.observers.ResourceObserver
+
+
Returns true if this ResourceObserver has been disposed/cancelled.
+
+
isDisposed() - Method in class io.reactivex.rxjava3.observers.ResourceSingleObserver
+
+
Returns true if this ResourceSingleObserver has been disposed/cancelled.
+
+
isDisposed() - Method in class io.reactivex.rxjava3.observers.SafeObserver
+
 
+
isDisposed() - Method in class io.reactivex.rxjava3.observers.SerializedObserver
+
 
+
isDisposed() - Method in class io.reactivex.rxjava3.observers.TestObserver
+
 
+
isDisposed() - Method in class io.reactivex.rxjava3.subscribers.DisposableSubscriber
+
 
+
isDisposed() - Method in class io.reactivex.rxjava3.subscribers.ResourceSubscriber
+
+
Returns true if this ResourceSubscriber has been disposed/cancelled.
+
+
isDisposed() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
 
+
isEmpty() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits true if the current Flowable is empty, otherwise false.
+
+
isEmpty() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Single that emits true if the current Maybe is empty, otherwise false.
+
+
isEmpty() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits true if the current Observable is empty, otherwise false.
+
+
isEmpty() - Method in interface io.reactivex.rxjava3.operators.SimpleQueue
+
+
Returns true if the queue is empty.
+
+
isEmpty() - Method in class io.reactivex.rxjava3.operators.SpscArrayQueue
+
 
+
isEmpty() - Method in class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue
+
 
+
isFailOnNonBlockingScheduler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns true if the blockingX operators fail + with an IllegalStateException on a non-blocking scheduler + such as computation or single.
+
+
isLockdown() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Returns true if the plugins were locked down.
+
+
isOnComplete() - Method in class io.reactivex.rxjava3.core.Notification
+
+
Returns true if this notification is an onComplete signal.
+
+
isOnError() - Method in class io.reactivex.rxjava3.core.Notification
+
+
Returns true if this notification is an onError signal and + Notification.getError() returns the contained Throwable.
+
+
isOnNext() - Method in class io.reactivex.rxjava3.core.Notification
+
+
Returns true if this notification is an onNext signal and + Notification.getValue() returns the contained value.
+
+
+ + + +

J

+
+
join(Publisher<? extends TRight>, Function<? super T, ? extends Publisher<TLeftEnd>>, Function<? super TRight, ? extends Publisher<TRightEnd>>, BiFunction<? super T, ? super TRight, ? extends R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Correlates the items emitted by two Publishers based on overlapping durations.
+
+
join(ObservableSource<? extends TRight>, Function<? super T, ? extends ObservableSource<TLeftEnd>>, Function<? super TRight, ? extends ObservableSource<TRightEnd>>, BiFunction<? super T, ? super TRight, ? extends R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Correlates the items emitted by two ObservableSources based on overlapping durations.
+
+
just(T) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that signals the given (constant reference) item and then completes.
+
+
just(T, T) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts two items into a Publisher that emits those items.
+
+
just(T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts three items into a Publisher that emits those items.
+
+
just(T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts four items into a Publisher that emits those items.
+
+
just(T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts five items into a Publisher that emits those items.
+
+
just(T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts six items into a Publisher that emits those items.
+
+
just(T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts seven items into a Publisher that emits those items.
+
+
just(T, T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts eight items into a Publisher that emits those items.
+
+
just(T, T, T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts nine items into a Publisher that emits those items.
+
+
just(T, T, T, T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts ten items into a Publisher that emits those items.
+
+
just(T) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits a specified item.
+
+
just(T) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that signals the given (constant reference) item and then completes.
+
+
just(T, T) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts two items into an Observable that emits those items.
+
+
just(T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts three items into an Observable that emits those items.
+
+
just(T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts four items into an Observable that emits those items.
+
+
just(T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts five items into an Observable that emits those items.
+
+
just(T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts six items into an Observable that emits those items.
+
+
just(T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts seven items into an Observable that emits those items.
+
+
just(T, T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts eight items into an Observable that emits those items.
+
+
just(T, T, T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts nine items into an Observable that emits those items.
+
+
just(T, T, T, T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts ten items into an Observable that emits those items.
+
+
just(T) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that emits a specified item.
+
+
+ + + +

L

+
+
LambdaConsumerIntrospection - Interface in io.reactivex.rxjava3.observers
+
+
An interface that indicates that the implementing type is composed of individual components and exposes information + about their behavior.
+
+
last(T) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits only the last item emitted by this Flowable, or a default item + if this Flowable completes without emitting any items.
+
+
last(T) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits only the last item emitted by the current Observable, or a default item + if the current Observable completes without emitting any items.
+
+
lastElement() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Maybe that emits the last item emitted by this Flowable or completes if + this Flowable is empty.
+
+
lastElement() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Maybe that emits the last item emitted by the current Observable or + completes if the current Observable is empty.
+
+
lastOrError() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits only the last item emitted by this Flowable or signals + a NoSuchElementException if this Flowable is empty.
+
+
lastOrError() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits only the last item emitted by the current Observable or + signals a NoSuchElementException if the current Observable is empty.
+
+
lastOrErrorStage() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Signals the last upstream item or a NoSuchElementException if the upstream is empty via + a CompletionStage.
+
+
lastOrErrorStage() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Signals the last upstream item or a NoSuchElementException if the upstream is empty via + a CompletionStage.
+
+
lastStage(T) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Signals the last upstream item (or the default item if the upstream is empty) via + a CompletionStage.
+
+
lastStage(T) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Signals the last upstream item (or the default item if the upstream is empty) via + a CompletionStage.
+
+
lastThread - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
The last thread seen by the observer.
+
+
lift(CompletableOperator) - Method in class io.reactivex.rxjava3.core.Completable
+
+
This method requires advanced knowledge about building operators, please consider + other standard composition methods first; + Returns a Completable which, when subscribed to, invokes the apply(CompletableObserver) method + of the provided CompletableOperator for each individual downstream Completable and allows the + insertion of a custom operator by accessing the downstream's CompletableObserver during this subscription phase + and providing a new CompletableObserver, containing the custom operator's intended business logic, that will be + used in the subscription process going further upstream.
+
+
lift(FlowableOperator<? extends R, ? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
This method requires advanced knowledge about building operators, please consider + other standard composition methods first; + Returns a Flowable which, when subscribed to, invokes the apply(Subscriber) method + of the provided FlowableOperator for each individual downstream Subscriber and allows the + insertion of a custom operator by accessing the downstream's Subscriber during this subscription phase + and providing a new Subscriber, containing the custom operator's intended business logic, that will be + used in the subscription process going further upstream.
+
+
lift(MaybeOperator<? extends R, ? super T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
This method requires advanced knowledge about building operators, please consider + other standard composition methods first; + Returns a Maybe which, when subscribed to, invokes the apply(MaybeObserver) method + of the provided MaybeOperator for each individual downstream Maybe and allows the + insertion of a custom operator by accessing the downstream's MaybeObserver during this subscription phase + and providing a new MaybeObserver, containing the custom operator's intended business logic, that will be + used in the subscription process going further upstream.
+
+
lift(ObservableOperator<? extends R, ? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
This method requires advanced knowledge about building operators, please consider + other standard composition methods first; + Returns an Observable which, when subscribed to, invokes the apply(Observer) method + of the provided ObservableOperator for each individual downstream Observer and allows the + insertion of a custom operator by accessing the downstream's Observer during this subscription phase + and providing a new Observer, containing the custom operator's intended business logic, that will be + used in the subscription process going further upstream.
+
+
lift(SingleOperator<? extends R, ? super T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
This method requires advanced knowledge about building operators, please consider + other standard composition methods first; + Returns a Single which, when subscribed to, invokes the apply(SingleObserver) method + of the provided SingleOperator for each individual downstream Single and allows the + insertion of a custom operator by accessing the downstream's SingleObserver during this subscription phase + and providing a new SingleObserver, containing the custom operator's intended business logic, that will be + used in the subscription process going further upstream.
+
+
lockdown() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Prevents changing the plugins from then on.
+
+
LongConsumer - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that consumes a primitive long value.
+
+
+ + + +

M

+
+
map(Function<? super T, ? extends R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that applies a specified function to each item emitted by the current Flowable and + emits the results of these function applications.
+
+
map(Function<? super T, ? extends R>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that applies a specified function to the item emitted by the current Maybe and + emits the result of this function application.
+
+
map(Function<? super T, ? extends R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that applies a specified function to each item emitted by the current Observable and + emits the results of these function applications.
+
+
map(Function<? super T, ? extends R>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that applies a specified function to the item emitted by the current Single and + emits the result of this function application.
+
+
map(Function<? super T, ? extends R>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Maps the source values on each 'rail' to another value.
+
+
map(Function<? super T, ? extends R>, ParallelFailureHandling) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Maps the source values on each 'rail' to another value and + handles errors based on the given ParallelFailureHandling enumeration value.
+
+
map(Function<? super T, ? extends R>, BiFunction<? super Long, ? super Throwable, ParallelFailureHandling>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Maps the source values on each 'rail' to another value and + handles errors based on the returned value by the handler function.
+
+
mapOptional(Function<? super T, Optional<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps each upstream value into an Optional and emits the contained item if not empty.
+
+
mapOptional(Function<? super T, Optional<? extends R>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Maps the upstream success value into an Optional and emits the contained item if not empty.
+
+
mapOptional(Function<? super T, Optional<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps each upstream value into an Optional and emits the contained item if not empty.
+
+
mapOptional(Function<? super T, Optional<? extends R>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Maps the upstream success value into an Optional and emits the contained item if not empty as a Maybe.
+
+
mapOptional(Function<? super T, Optional<? extends R>>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Maps the source values on each 'rail' to an optional and emits its value if any.
+
+
mapOptional(Function<? super T, Optional<? extends R>>, ParallelFailureHandling) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Maps the source values on each 'rail' to an optional and emits its value if any and + handles errors based on the given ParallelFailureHandling enumeration value.
+
+
mapOptional(Function<? super T, Optional<? extends R>>, BiFunction<? super Long, ? super Throwable, ParallelFailureHandling>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Maps the source values on each 'rail' to an optional and emits its value if any and + handles errors based on the returned value by the handler function.
+
+
materialize() - Method in class io.reactivex.rxjava3.core.Completable
+
+
Maps the signal types of this Completable into a Notification of the same kind + and emits it as a single success value to downstream.
+
+
materialize() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that represents all of the emissions and notifications from the current + Flowable into emissions marked with their original types within Notification objects.
+
+
materialize() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Maps the signal types of this Maybe into a Notification of the same kind + and emits it as a Single's onSuccess value to downstream.
+
+
materialize() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that represents all of the emissions and notifications from the current + Observable into emissions marked with their original types within Notification objects.
+
+
materialize() - Method in class io.reactivex.rxjava3.core.Single
+
+
Maps the signal types of this Single into a Notification of the same kind + and emits it as a single success value to downstream.
+
+
Maybe<T> - Class in io.reactivex.rxjava3.core
+
+
The Maybe class represents a deferred computation and emission of a single value, no value at all or an exception.
+
+
Maybe() - Constructor for class io.reactivex.rxjava3.core.Maybe
+
 
+
MaybeConverter<T,R> - Interface in io.reactivex.rxjava3.core
+
+
Convenience interface and callback used by the Maybe.to(io.reactivex.rxjava3.core.MaybeConverter<T, ? extends R>) operator to turn a Maybe into another + value fluently.
+
+
MaybeEmitter<T> - Interface in io.reactivex.rxjava3.core
+
+
Abstraction over an RxJava MaybeObserver that allows associating + a resource with it.
+
+
MaybeObserver<T> - Interface in io.reactivex.rxjava3.core
+
+
Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
+
+
MaybeOnSubscribe<T> - Interface in io.reactivex.rxjava3.core
+
+
A functional interface that has a subscribe() method that receives + a MaybeEmitter instance that allows pushing + an event in a cancellation-safe manner.
+
+
MaybeOperator<Downstream,Upstream> - Interface in io.reactivex.rxjava3.core
+
+
Interface to map/wrap a downstream MaybeObserver to an upstream MaybeObserver.
+
+
MaybeSource<T> - Interface in io.reactivex.rxjava3.core
+
+
Represents a basic Maybe source base interface, + consumable via an MaybeObserver.
+
+
MaybeSubject<T> - Class in io.reactivex.rxjava3.subjects
+
+
Represents a hot Maybe-like source and consumer of events similar to Subjects.
+
+
MaybeTransformer<Upstream,Downstream> - Interface in io.reactivex.rxjava3.core
+
+
Interface to compose Maybes.
+
+
merge(Iterable<? extends CompletableSource>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that subscribes to all sources at once and + completes only when all source CompletableSources complete or one of them emits an error.
+
+
merge(Publisher<? extends CompletableSource>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that subscribes to all sources at once and + completes only when all source CompletableSources complete or one of them emits an error.
+
+
merge(Publisher<? extends CompletableSource>, int) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that keeps subscriptions to a limited number of sources at once and + completes only when all source CompletableSources complete or one of them emits an error.
+
+
merge(Iterable<? extends Publisher<? extends T>>, int, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the + number of concurrent subscriptions to these Publishers.
+
+
merge(Iterable<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens an Iterable of Publishers into one Publisher, without any transformation.
+
+
merge(Iterable<? extends Publisher<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the + number of concurrent subscriptions to these Publishers.
+
+
merge(Publisher<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by + thos Publishers , without any transformation.
+
+
merge(Publisher<? extends Publisher<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by + those Publishers, without any transformation, while limiting the maximum number of concurrent + subscriptions to these Publishers.
+
+
merge(Publisher<? extends T>, Publisher<? extends T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens two Publishers into a single Publisher, without any transformation.
+
+
merge(Publisher<? extends T>, Publisher<? extends T>, Publisher<? extends T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens three Publishers into a single Publisher, without any transformation.
+
+
merge(Publisher<? extends T>, Publisher<? extends T>, Publisher<? extends T>, Publisher<? extends T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens four Publishers into a single Publisher, without any transformation.
+
+
merge(Iterable<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Merges an Iterable sequence of MaybeSource instances into a single Flowable sequence, + running all MaybeSources at once.
+
+
merge(Publisher<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Merges a Publisher sequence of MaybeSource instances into a single Flowable sequence, + running all MaybeSources at once.
+
+
merge(Publisher<? extends MaybeSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Merges a Publisher sequence of MaybeSource instances into a single Flowable sequence, + running at most maxConcurrency MaybeSources at once.
+
+
merge(MaybeSource<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Flattens a MaybeSource that emits a MaybeSource into a single MaybeSource that emits the item + emitted by the nested MaybeSource, without any transformation.
+
+
merge(MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Flattens two MaybeSources into a single Flowable, without any transformation.
+
+
merge(MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Flattens three MaybeSources into a single Flowable, without any transformation.
+
+
merge(MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Flattens four MaybeSources into a single Flowable, without any transformation.
+
+
merge(Iterable<? extends ObservableSource<? extends T>>, int, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens an Iterable of ObservableSources into one Observable, without any transformation, while limiting the + number of concurrent subscriptions to these ObservableSources.
+
+
merge(Iterable<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens an Iterable of ObservableSources into one Observable, without any transformation.
+
+
merge(Iterable<? extends ObservableSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens an Iterable of ObservableSources into one Observable, without any transformation, while limiting the + number of concurrent subscriptions to these ObservableSources.
+
+
merge(ObservableSource<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens an ObservableSource that emits ObservableSources into a single Observable that emits the items emitted by + those ObservableSources, without any transformation.
+
+
merge(ObservableSource<? extends ObservableSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens an ObservableSource that emits ObservableSources into a single Observable that emits the items emitted by + those ObservableSources, without any transformation, while limiting the maximum number of concurrent + subscriptions to these ObservableSources.
+
+
merge(ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens two ObservableSources into a single Observable, without any transformation.
+
+
merge(ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens three ObservableSources into a single Observable, without any transformation.
+
+
merge(ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens four ObservableSources into a single Observable, without any transformation.
+
+
merge(Iterable<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Merges an Iterable sequence of SingleSource instances into a single Flowable sequence, + running all SingleSources at once.
+
+
merge(Publisher<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Merges a sequence of SingleSource instances emitted by a Publisher into a single Flowable sequence, + running all SingleSources at once.
+
+
merge(SingleSource<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Flattens a SingleSource that emits a SingleSingle into a single Single that emits the item + emitted by the nested SingleSource, without any transformation.
+
+
merge(SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Flattens two SingleSources into one Flowable sequence, without any transformation.
+
+
merge(SingleSource<? extends T>, SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Flattens three SingleSources into one Flowable sequence, without any transformation.
+
+
merge(SingleSource<? extends T>, SingleSource<? extends T>, SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Flattens four SingleSources into one Flowable sequence, without any transformation.
+
+
mergeArray(CompletableSource...) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that subscribes to all sources at once and + completes only when all source CompletableSources complete or one of them emits an error.
+
+
mergeArray(int, int, Publisher<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens an array of Publishers into one Publisher, without any transformation, while limiting the + number of concurrent subscriptions to these Publishers.
+
+
mergeArray(Publisher<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens an array of Publishers into one Publisher, without any transformation.
+
+
mergeArray(MaybeSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Merges an array of MaybeSource instances into a single Flowable sequence, + running all MaybeSources at once.
+
+
mergeArray(int, int, ObservableSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens an array of ObservableSources into one Observable, without any transformation, while limiting the + number of concurrent subscriptions to these ObservableSources.
+
+
mergeArray(ObservableSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens an array of ObservableSources into one Observable, without any transformation.
+
+
mergeArray(SingleSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Merges an array of SingleSource instances into a single Flowable sequence, + running all SingleSources at once.
+
+
mergeArrayDelayError(CompletableSource...) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that subscribes to all CompletableSources in the source array and delays + any error emitted by any of the inner CompletableSources until all of + them terminate in a way or another.
+
+
mergeArrayDelayError(int, int, Publisher<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens an array of Publishers into one Publisher, in a way that allows a Subscriber to receive all + successfully emitted items from each of the source Publishers without being interrupted by an error + notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
+
+
mergeArrayDelayError(Publisher<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens an array of Publishers into one Flowable, in a way that allows a Subscriber to receive all + successfully emitted items from each of the source Publishers without being interrupted by an error + notification from one of them.
+
+
mergeArrayDelayError(MaybeSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Flattens an array of MaybeSources into one Flowable, in a way that allows a subscriber to receive all + successfully emitted items from each of the source MaybeSources without being interrupted by an error + notification from one of them.
+
+
mergeArrayDelayError(int, int, ObservableSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens an array of ObservableSources into one Observable, in a way that allows an Observer to receive all + successfully emitted items from each of the ObservableSources without being interrupted by an error + notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
+
+
mergeArrayDelayError(ObservableSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens an array of ObservableSources into one Observable, in a way that allows an Observer to receive all + successfully emitted items from each of the ObservableSources without being interrupted by an error + notification from one of them.
+
+
mergeArrayDelayError(SingleSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Flattens an array of SingleSources into one Flowable, in a way that allows a subscriber to receive all + successfully emitted items from each of the source SingleSources without being interrupted by an error + notification from one of them.
+
+
mergeDelayError(Iterable<? extends CompletableSource>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that subscribes to all CompletableSources in the source sequence and delays + any error emitted by any of the inner CompletableSources until all of + them terminate in a way or another.
+
+
mergeDelayError(Publisher<? extends CompletableSource>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that subscribes to all CompletableSources in the source sequence and delays + any error emitted by either the sources Publisher or any of the inner CompletableSources until all of + them terminate in a way or another.
+
+
mergeDelayError(Publisher<? extends CompletableSource>, int) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that subscribes to a limited number of inner CompletableSources at once in + the source sequence and delays any error emitted by either the sources + Publisher or any of the inner CompletableSources until all of + them terminate in a way or another.
+
+
mergeDelayError(Iterable<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all + successfully emitted items from each of the source Publishers without being interrupted by an error + notification from one of them.
+
+
mergeDelayError(Iterable<? extends Publisher<? extends T>>, int, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all + successfully emitted items from each of the source Publishers without being interrupted by an error + notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
+
+
mergeDelayError(Iterable<? extends Publisher<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all + successfully emitted items from each of the source Publishers without being interrupted by an error + notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
+
+
mergeDelayError(Publisher<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to + receive all successfully emitted items from all of the source Publishers without being interrupted by + an error notification from one of them.
+
+
mergeDelayError(Publisher<? extends Publisher<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to + receive all successfully emitted items from all of the source Publishers without being interrupted by + an error notification from one of them, while limiting the + number of concurrent subscriptions to these Publishers.
+
+
mergeDelayError(Publisher<? extends T>, Publisher<? extends T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens two Publishers into one Publisher, in a way that allows a Subscriber to receive all + successfully emitted items from each of the source Publishers without being interrupted by an error + notification from one of them.
+
+
mergeDelayError(Publisher<? extends T>, Publisher<? extends T>, Publisher<? extends T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens three Publishers into one Publisher, in a way that allows a Subscriber to receive all + successfully emitted items from all of the source Publishers without being interrupted by an error + notification from one of them.
+
+
mergeDelayError(Publisher<? extends T>, Publisher<? extends T>, Publisher<? extends T>, Publisher<? extends T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens four Publishers into one Publisher, in a way that allows a Subscriber to receive all + successfully emitted items from all of the source Publishers without being interrupted by an error + notification from one of them.
+
+
mergeDelayError(Iterable<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Flattens an Iterable sequence of MaybeSources into one Flowable, in a way that allows a subscriber to receive all + successfully emitted items from each of the source MaybeSources without being interrupted by an error + notification from one of them.
+
+
mergeDelayError(Publisher<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Flattens a Publisher that emits MaybeSources into one Flowable, in a way that allows a subscriber to + receive all successfully emitted items from all of the source MaybeSources without being interrupted by + an error notification from one of them or even the main Publisher.
+
+
mergeDelayError(Publisher<? extends MaybeSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Flattens a Publisher that emits MaybeSources into one Flowable, in a way that allows a subscriber to + receive all successfully emitted items from all of the source MaybeSources without being interrupted by + an error notification from one of them or even the main Publisher as well as limiting the total number of active MaybeSources.
+
+
mergeDelayError(MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Flattens two MaybeSources into one Flowable, in a way that allows a subscriber to receive all + successfully emitted items from each of the source MaybeSources without being interrupted by an error + notification from one of them.
+
+
mergeDelayError(MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Flattens three MaybeSource into one Flowable, in a way that allows a subscriber to receive all + successfully emitted items from all of the source MaybeSources without being interrupted by an error + notification from one of them.
+
+
mergeDelayError(MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Flattens four MaybeSources into one Flowable, in a way that allows a subscriber to receive all + successfully emitted items from all of the source MaybeSources without being interrupted by an error + notification from one of them.
+
+
mergeDelayError(Iterable<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all + successfully emitted items from each of the returned ObservableSources without being interrupted by an error + notification from one of them.
+
+
mergeDelayError(Iterable<? extends ObservableSource<? extends T>>, int, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all + successfully emitted items from each of the returned ObservableSources without being interrupted by an error + notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
+
+
mergeDelayError(Iterable<? extends ObservableSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all + successfully emitted items from each of the returned ObservableSources without being interrupted by an error + notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
+
+
mergeDelayError(ObservableSource<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens an ObservableSource that emits ObservableSources into one Observable, in a way that allows an Observer to + receive all successfully emitted items from all of the emitted ObservableSources without being interrupted by + an error notification from one of them.
+
+
mergeDelayError(ObservableSource<? extends ObservableSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens an ObservableSource that emits ObservableSources into one Observable, in a way that allows an Observer to + receive all successfully emitted items from all of the emitted ObservableSources without being interrupted by + an error notification from one of them, while limiting the + number of concurrent subscriptions to these ObservableSources.
+
+
mergeDelayError(ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens two ObservableSources into one Observable, in a way that allows an Observer to receive all + successfully emitted items from each of the ObservableSources without being interrupted by an error + notification from one of them.
+
+
mergeDelayError(ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens three ObservableSources into one Observable, in a way that allows an Observer to receive all + successfully emitted items from all of the ObservableSources without being interrupted by an error + notification from one of them.
+
+
mergeDelayError(ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens four ObservableSources into one Observable, in a way that allows an Observer to receive all + successfully emitted items from all of the ObservableSources without being interrupted by an error + notification from one of them.
+
+
mergeDelayError(Iterable<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Merges an Iterable sequence of SingleSource instances into one Flowable sequence, + running all SingleSources at once and delaying any error(s) until all sources succeed or fail.
+
+
mergeDelayError(Publisher<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Merges a sequence of SingleSource instances emitted by a Publisher into a Flowable sequence, + running all SingleSources at once and delaying any error(s) until all sources succeed or fail.
+
+
mergeDelayError(SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Flattens two SingleSources into one Flowable, without any transformation, delaying + any error(s) until all sources succeed or fail.
+
+
mergeDelayError(SingleSource<? extends T>, SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Flattens two SingleSources into one Flowable, without any transformation, delaying + any error(s) until all sources succeed or fail.
+
+
mergeDelayError(SingleSource<? extends T>, SingleSource<? extends T>, SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Flattens two SingleSources into one Flowable, without any transformation, delaying + any error(s) until all sources succeed or fail.
+
+
mergeWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which subscribes to this and the other CompletableSource and completes + when both of them complete or one emits an error.
+
+
mergeWith(Publisher<? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Flattens this and another Publisher into a single Publisher, without any transformation.
+
+
mergeWith(SingleSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Merges the sequence of items of this Flowable with the success value of the other SingleSource.
+
+
mergeWith(MaybeSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Merges the sequence of items of this Flowable with the success value of the other MaybeSource + or waits for both to complete normally if the MaybeSource is empty.
+
+
mergeWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Relays the items of this Flowable and completes only when the other CompletableSource completes + as well.
+
+
mergeWith(MaybeSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Flattens this Maybe and another MaybeSource into a single Flowable, without any transformation.
+
+
mergeWith(ObservableSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Flattens the current Observable and another ObservableSource into a single Observable sequence, without any transformation.
+
+
mergeWith(SingleSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Merges the sequence of items of the current Observable with the success value of the other SingleSource.
+
+
mergeWith(MaybeSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Merges the sequence of items of the current Observable with the success value of the other MaybeSource + or waits both to complete normally if the MaybeSource is empty.
+
+
mergeWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Relays the items of the current Observable and completes only when the other CompletableSource completes + as well.
+
+
mergeWith(SingleSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Flattens this Single and another SingleSource into one Flowable, without any transformation.
+
+
MissingBackpressureException - Exception in io.reactivex.rxjava3.exceptions
+
+
Indicates that an operator attempted to emit a value but the downstream wasn't ready for it.
+
+
MissingBackpressureException() - Constructor for exception io.reactivex.rxjava3.exceptions.MissingBackpressureException
+
+
Constructs a MissingBackpressureException without message or cause.
+
+
MissingBackpressureException(String) - Constructor for exception io.reactivex.rxjava3.exceptions.MissingBackpressureException
+
+
Constructs a MissingBackpressureException with the given message but no cause.
+
+
MulticastProcessor<T> - Class in io.reactivex.rxjava3.processors
+
+
A FlowableProcessor implementation that coordinates downstream requests through + a front-buffer and stable-prefetching, optionally canceling the upstream if all + subscribers have cancelled.
+
+
+ + + +

N

+
+
never() - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that never calls onError or onComplete.
+
+
never() - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that never sends any items or notifications to a Subscriber.
+
+
never() - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that never sends any items or notifications to a MaybeObserver.
+
+
never() - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that never sends any items or notifications to an Observer.
+
+
never() - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a singleton instance of a never-signaling Single (only calls onSubscribe).
+
+
NEW_THREAD - Static variable in annotation type io.reactivex.rxjava3.annotations.SchedulerSupport
+
+
The operator/class runs on RxJava's new thread scheduler + or takes timing information from it.
+
+
newThread() - Static method in class io.reactivex.rxjava3.schedulers.Schedulers
+
+
Returns a default, shared Scheduler instance that creates a new Thread for each unit of work.
+
+
NONE - Static variable in annotation type io.reactivex.rxjava3.annotations.SchedulerSupport
+
+
A special value indicating the operator/class doesn't use schedulers.
+
+
NONE - Static variable in interface io.reactivex.rxjava3.operators.QueueFuseable
+
+
Returned by the QueueFuseable.requestFusion(int) if the upstream doesn't support + the requested mode.
+
+
NonNull - Annotation Type in io.reactivex.rxjava3.annotations
+
+
Indicates that a field/parameter/variable/type parameter/return type is never null.
+
+
Notification<T> - Class in io.reactivex.rxjava3.core
+
+
Represents the reactive signal types: onNext, onError and onComplete and + holds their parameter values (a value, a Throwable, nothing).
+
+
now(TimeUnit) - Method in class io.reactivex.rxjava3.core.Scheduler
+
+
Returns the 'current time' of the Scheduler in the specified time unit.
+
+
now(TimeUnit) - Method in class io.reactivex.rxjava3.core.Scheduler.Worker
+
+
Returns the 'current time' of the Worker in the specified time unit.
+
+
now(TimeUnit) - Method in class io.reactivex.rxjava3.schedulers.TestScheduler
+
 
+
Nullable - Annotation Type in io.reactivex.rxjava3.annotations
+
+
Indicates that a field/parameter/variable/type parameter/return type may be null.
+
+
+ + + +

O

+
+
Observable<T> - Class in io.reactivex.rxjava3.core
+
+
The Observable class is the non-backpressured, optionally multi-valued base reactive class that + offers factory methods, intermediate operators and the ability to consume synchronous + and/or asynchronous reactive dataflows.
+
+
Observable() - Constructor for class io.reactivex.rxjava3.core.Observable
+
 
+
ObservableConverter<T,R> - Interface in io.reactivex.rxjava3.core
+
+
Convenience interface and callback used by the Observable.to(io.reactivex.rxjava3.core.ObservableConverter<T, ? extends R>) operator to turn an Observable into another + value fluently.
+
+
ObservableEmitter<T> - Interface in io.reactivex.rxjava3.core
+
+
Abstraction over an RxJava Observer that allows associating + a resource with it.
+
+
ObservableOnSubscribe<T> - Interface in io.reactivex.rxjava3.core
+
+
A functional interface that has a subscribe() method that receives + an ObservableEmitter instance that allows pushing + events in a cancellation-safe manner.
+
+
ObservableOperator<Downstream,Upstream> - Interface in io.reactivex.rxjava3.core
+
+
Interface to map/wrap a downstream Observer to an upstream Observer.
+
+
ObservableSource<T> - Interface in io.reactivex.rxjava3.core
+
+
Represents a basic, non-backpressured Observable source base interface, + consumable via an Observer.
+
+
ObservableTransformer<Upstream,Downstream> - Interface in io.reactivex.rxjava3.core
+
+
Interface to compose Observables.
+
+
observeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which emits the terminal events from the thread of the specified Scheduler.
+
+
observeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Signals the items and terminal signals of the current Flowable on the specified Scheduler, + asynchronously with a bounded buffer of Flowable.bufferSize() slots.
+
+
observeOn(Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Signals the items and terminal signals of the current Flowable on the specified Scheduler, + asynchronously with a bounded buffer and optionally delays onError notifications.
+
+
observeOn(Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Signals the items and terminal signals of the current Flowable on the specified Scheduler, + asynchronously with a bounded buffer of configurable size and optionally delays onError notifications.
+
+
observeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Wraps a Maybe to emit its item (or notify of its error) on a specified Scheduler, + asynchronously.
+
+
observeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, + asynchronously with an unbounded buffer with Flowable.bufferSize() "island size".
+
+
observeOn(Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, + asynchronously with an unbounded buffer with Flowable.bufferSize() "island size" and optionally delays onError notifications.
+
+
observeOn(Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, + asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications.
+
+
observeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Single
+
+
Signals the success item or the terminal signals of the current Single on the specified Scheduler, + asynchronously.
+
+
Observer<T> - Interface in io.reactivex.rxjava3.core
+
+
Provides a mechanism for receiving push-based notifications.
+
+
offer(T) - Method in interface io.reactivex.rxjava3.operators.SimpleQueue
+
+
Atomically enqueue a single value.
+
+
offer(T, T) - Method in interface io.reactivex.rxjava3.operators.SimpleQueue
+
+
Atomically enqueue two values.
+
+
offer(E) - Method in class io.reactivex.rxjava3.operators.SpscArrayQueue
+
 
+
offer(E, E) - Method in class io.reactivex.rxjava3.operators.SpscArrayQueue
+
 
+
offer(T) - Method in class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue
+
+
Atomically enqueue a single value.
+
+
offer(T, T) - Method in class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue
+
+
Offer two elements at the same time.
+
+
offer(T) - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor
+
+
Tries to emit the item to all currently subscribed Subscribers if all of them + has requested some value, returns false otherwise.
+
+
offer(T) - Method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
+
Tries to offer an item into the internal queue and returns false + if the queue is full.
+
+
offer(T) - Method in class io.reactivex.rxjava3.processors.PublishProcessor
+
+
Tries to emit the item to all currently subscribed Subscribers if all of them + has requested some value, returns false otherwise.
+
+
ofType(Class<U>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Filters the items emitted by the current Flowable, only emitting those of the specified type.
+
+
ofType(Class<U>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Filters the items emitted by the current Maybe, only emitting its success value if that + is an instance of the supplied Class.
+
+
ofType(Class<U>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Filters the items emitted by the current Observable, only emitting those of the specified type.
+
+
ofType(Class<U>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Filters the items emitted by the current Single, only emitting its success value if that + is an instance of the supplied Class.
+
+
onAssembly(Maybe<T>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onAssembly(Flowable<T>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onAssembly(ConnectableFlowable<T>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onAssembly(Observable<T>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onAssembly(ConnectableObservable<T>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onAssembly(Single<T>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onAssembly(Completable) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onAssembly(ParallelFlowable<T>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onBackpressureBuffer() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Buffers an unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place.
+
+
onBackpressureBuffer(boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Buffers an unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place, optionally delaying an error until all buffered items have been consumed.
+
+
onBackpressureBuffer(int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Buffers an limited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place, however, the resulting Flowable will signal a + MissingBackpressureException via onError as soon as the buffer's capacity is exceeded, dropping all undelivered + items, and canceling the flow.
+
+
onBackpressureBuffer(int, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Buffers an limited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place, however, the resulting Flowable will signal a + MissingBackpressureException via onError as soon as the buffer's capacity is exceeded, dropping all undelivered + items, and canceling the flow.
+
+
onBackpressureBuffer(int, boolean, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place.
+
+
onBackpressureBuffer(int, boolean, boolean, Action) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place.
+
+
onBackpressureBuffer(int, boolean, boolean, Action, Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place.
+
+
onBackpressureBuffer(int, Action) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Buffers an limited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place, however, the resulting Flowable will signal a + MissingBackpressureException via onError as soon as the buffer's capacity is exceeded, dropping all undelivered + items, canceling the flow and calling the onOverflow action.
+
+
onBackpressureBuffer(long, Action, BackpressureOverflowStrategy) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place.
+
+
onBackpressureBuffer(long, Action, BackpressureOverflowStrategy, Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place.
+
+
onBackpressureDrop() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Drops items from the current Flowable if the downstream is not ready to receive new items (indicated + by a lack of Subscription.request(long) calls from it).
+
+
onBackpressureDrop(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Drops items from the current Flowable if the downstream is not ready to receive new items (indicated + by a lack of Subscription.request(long) calls from it) and calls the given Consumer with such + dropped items.
+
+
onBackpressureLatest() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Drops all but the latest item emitted by the current Flowable if the downstream is not ready to receive + new items (indicated by a lack of Subscription.request(long) calls from it) and emits this latest + item when the downstream becomes ready.
+
+
onBackpressureLatest(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Drops all but the latest item emitted by the current Flowable if the downstream is not ready to receive + new items (indicated by a lack of Subscription.request(long) calls from it) and emits this latest + item when the downstream becomes ready.
+
+
onBackpressureReduce(BiFunction<T, T, T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Reduces a sequence of two not emitted values via a function into a single value if the downstream is not ready to receive + new items (indicated by a lack of Subscription.request(long) calls from it) and emits this latest + item when the downstream becomes ready.
+
+
onBackpressureReduce(Supplier<R>, BiFunction<R, ? super T, R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Reduces upstream values into an aggregate value, provided by a supplier and combined via a reducer function, + while the downstream is not ready to receive items, then emits this aggregate value when the downstream becomes ready.
+
+
onBeforeBlocking() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Called before an operator attempts a blocking operation + such as awaiting a condition or signal + and should return true to indicate the operator + should not block but throw an IllegalArgumentException.
+
+
onComplete() - Method in interface io.reactivex.rxjava3.core.CompletableEmitter
+
+
Signal the completion.
+
+
onComplete() - Method in interface io.reactivex.rxjava3.core.CompletableObserver
+
+
Called once the deferred computation completes normally.
+
+
onComplete() - Method in interface io.reactivex.rxjava3.core.Emitter
+
+
Signal a completion.
+
+
onComplete() - Method in interface io.reactivex.rxjava3.core.MaybeEmitter
+
+
Signal the completion.
+
+
onComplete() - Method in interface io.reactivex.rxjava3.core.MaybeObserver
+
+
Called once the deferred computation completes normally.
+
+
onComplete() - Method in interface io.reactivex.rxjava3.core.Observer
+
+
Notifies the Observer that the Observable has finished sending push-based notifications.
+
+
onComplete() - Method in class io.reactivex.rxjava3.observers.SafeObserver
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.observers.SerializedObserver
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.observers.TestObserver
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.processors.AsyncProcessor
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.processors.PublishProcessor
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.processors.UnicastProcessor
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.subjects.AsyncSubject
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.subjects.CompletableSubject
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.subjects.MaybeSubject
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.subjects.PublishSubject
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.subjects.UnicastSubject
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.subscribers.SafeSubscriber
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.subscribers.SerializedSubscriber
+
 
+
onComplete() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
 
+
onComputationScheduler(Scheduler) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onError(Throwable) - Method in interface io.reactivex.rxjava3.core.CompletableEmitter
+
+
Signal an exception.
+
+
onError(Throwable) - Method in interface io.reactivex.rxjava3.core.CompletableObserver
+
+
Called once if the deferred computation 'throws' an exception.
+
+
onError(Throwable) - Method in interface io.reactivex.rxjava3.core.Emitter
+
+
Signal a Throwable exception.
+
+
onError(Throwable) - Method in interface io.reactivex.rxjava3.core.MaybeEmitter
+
+
Signal an exception.
+
+
onError(Throwable) - Method in interface io.reactivex.rxjava3.core.MaybeObserver
+
+
Notifies the MaybeObserver that the Maybe has experienced an error condition.
+
+
onError(Throwable) - Method in interface io.reactivex.rxjava3.core.Observer
+
+
Notifies the Observer that the Observable has experienced an error condition.
+
+
onError(Throwable) - Method in interface io.reactivex.rxjava3.core.SingleEmitter
+
+
Signal an exception.
+
+
onError(Throwable) - Method in interface io.reactivex.rxjava3.core.SingleObserver
+
+
Notifies the SingleObserver that the Single has experienced an error condition.
+
+
onError(Throwable) - Method in class io.reactivex.rxjava3.observers.SafeObserver
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.observers.SerializedObserver
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.observers.TestObserver
+
 
+
onError(Throwable) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Called when an undeliverable error occurs.
+
+
onError(Throwable) - Method in class io.reactivex.rxjava3.processors.AsyncProcessor
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.processors.PublishProcessor
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.processors.UnicastProcessor
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.AsyncSubject
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.CompletableSubject
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.MaybeSubject
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.PublishSubject
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.SingleSubject
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.UnicastSubject
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.subscribers.SafeSubscriber
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.subscribers.SerializedSubscriber
+
 
+
onError(Throwable) - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
 
+
onErrorComplete() - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that if this Completable emits an error, it will emit an onComplete + and swallow the upstream Throwable.
+
+
onErrorComplete(Predicate<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that if this Completable emits an error and the Predicate returns + true, it will emit an onComplete and swallow the Throwable.
+
+
onErrorComplete() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable instance that if the current Flowable emits an error, it will emit an onComplete + and swallow the throwable.
+
+
onErrorComplete(Predicate<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable instance that if the current Flowable emits an error and the predicate returns + true, it will emit an onComplete and swallow the throwable.
+
+
onErrorComplete() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe instance that if this Maybe emits an error, it will emit an onComplete + and swallow the throwable.
+
+
onErrorComplete(Predicate<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe instance that if this Maybe emits an error and the predicate returns + true, it will emit an onComplete and swallow the throwable.
+
+
onErrorComplete() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable instance that if the current Observable emits an error, it will emit an onComplete + and swallow the throwable.
+
+
onErrorComplete(Predicate<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable instance that if the current Observable emits an error and the predicate returns + true, it will emit an onComplete and swallow the throwable.
+
+
onErrorComplete() - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Maybe instance that if the current Single emits an error, it will emit an onComplete + and swallow the throwable.
+
+
onErrorComplete(Predicate<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Maybe instance that if this Single emits an error and the predicate returns + true, it will emit an onComplete and swallow the throwable.
+
+
OnErrorNotImplementedException - Exception in io.reactivex.rxjava3.exceptions
+
+
Represents an exception used to signal to the RxJavaPlugins.onError() that a + callback-based subscribe() method on a base reactive type didn't specify + an onError handler.
+
+
OnErrorNotImplementedException(String, Throwable) - Constructor for exception io.reactivex.rxjava3.exceptions.OnErrorNotImplementedException
+
+
Customizes the Throwable with a custom message and wraps it before it + is signalled to the RxJavaPlugins.onError() handler as OnErrorNotImplementedException.
+
+
OnErrorNotImplementedException(Throwable) - Constructor for exception io.reactivex.rxjava3.exceptions.OnErrorNotImplementedException
+
+
Wraps the Throwable before it + is signalled to the RxJavaPlugins.onError() + handler as OnErrorNotImplementedException.
+
+
onErrorResumeNext(Function<? super Throwable, ? extends CompletableSource>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that when encounters an error from this Completable, calls the + specified mapper Function that returns a CompletableSource instance for it and resumes the + execution with it.
+
+
onErrorResumeNext(Function<? super Throwable, ? extends Publisher<? extends T>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Resumes the flow with a Publisher returned for the failure Throwable of the current Flowable by a + function instead of signaling the error via onError.
+
+
onErrorResumeNext(Function<? super Throwable, ? extends MaybeSource<? extends T>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Resumes the flow with a MaybeSource returned for the failure Throwable of the current Maybe by a + function instead of signaling the error via onError.
+
+
onErrorResumeNext(Function<? super Throwable, ? extends ObservableSource<? extends T>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Resumes the flow with an ObservableSource returned for the failure Throwable of the current Observable by a + function instead of signaling the error via onError.
+
+
onErrorResumeNext(Function<? super Throwable, ? extends SingleSource<? extends T>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Resumes the flow with a SingleSource returned for the failure Throwable of the current Single by a + function instead of signaling the error via onError.
+
+
onErrorResumeWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Resumes the flow with the given CompletableSource when the current Completable fails instead of + signaling the error via onError.
+
+
onErrorResumeWith(Publisher<? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Resumes the flow with the given Publisher when the current Flowable fails instead of + signaling the error via onError.
+
+
onErrorResumeWith(MaybeSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Resumes the flow with the given MaybeSource when the current Maybe fails instead of + signaling the error via onError.
+
+
onErrorResumeWith(ObservableSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Resumes the flow with the given ObservableSource when the current Observable fails instead of + signaling the error via onError.
+
+
onErrorResumeWith(SingleSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Resumes the flow with the given SingleSource when the current Single fails instead of + signaling the error via onError.
+
+
onErrorReturn(Function<? super Throwable, ? extends T>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Ends the flow with a success item returned by a function for the Throwable error signaled by the current + Completable instead of signaling the error via onError.
+
+
onErrorReturn(Function<? super Throwable, ? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Ends the flow with a last item returned by a function for the Throwable error signaled by the current + Flowable instead of signaling the error via onError.
+
+
onErrorReturn(Function<? super Throwable, ? extends T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Ends the flow with a success item returned by a function for the Throwable error signaled by the current + Maybe instead of signaling the error via onError.
+
+
onErrorReturn(Function<? super Throwable, ? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Ends the flow with a last item returned by a function for the Throwable error signaled by the current + Observable instead of signaling the error via onError.
+
+
onErrorReturn(Function<Throwable, ? extends T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Ends the flow with a success item returned by a function for the Throwable error signaled by the current + Single instead of signaling the error via onError.
+
+
onErrorReturnItem(T) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Ends the flow with the given success item when the current Completable + fails instead of signaling the error via onError.
+
+
onErrorReturnItem(T) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Ends the flow with the given last item when the current Flowable fails instead of signaling the error via onError.
+
+
onErrorReturnItem(T) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Ends the flow with the given success item when the current Maybe fails instead of signaling the error via onError.
+
+
onErrorReturnItem(T) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Ends the flow with the given last item when the current Observable fails instead of signaling the error via onError.
+
+
onErrorReturnItem(T) - Method in class io.reactivex.rxjava3.core.Single
+
+
Signals the specified value as success in case the current Single signals an error.
+
+
onIoScheduler(Scheduler) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onNewThreadScheduler(Scheduler) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onNext(T) - Method in interface io.reactivex.rxjava3.core.Emitter
+
+
Signal a normal value.
+
+
onNext(T) - Method in interface io.reactivex.rxjava3.core.Observer
+
+
Provides the Observer with a new item to observe.
+
+
onNext(T) - Method in class io.reactivex.rxjava3.observers.SafeObserver
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.observers.SerializedObserver
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.observers.TestObserver
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.processors.AsyncProcessor
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.processors.PublishProcessor
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.processors.UnicastProcessor
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.subjects.AsyncSubject
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.subjects.PublishSubject
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.subjects.UnicastSubject
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.subscribers.SafeSubscriber
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.subscribers.SerializedSubscriber
+
 
+
onNext(T) - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
 
+
onSchedule(Runnable) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Called when a task is scheduled.
+
+
onSingleScheduler(Scheduler) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onStart() - Method in class io.reactivex.rxjava3.observers.DefaultObserver
+
+
Called once the subscription has been set on this observer; override this + to perform initialization.
+
+
onStart() - Method in class io.reactivex.rxjava3.observers.DisposableCompletableObserver
+
+
Called once the single upstream Disposable is set via DisposableCompletableObserver.onSubscribe(Disposable).
+
+
onStart() - Method in class io.reactivex.rxjava3.observers.DisposableMaybeObserver
+
+
Called once the single upstream Disposable is set via DisposableMaybeObserver.onSubscribe(Disposable).
+
+
onStart() - Method in class io.reactivex.rxjava3.observers.DisposableObserver
+
+
Called once the single upstream Disposable is set via onSubscribe.
+
+
onStart() - Method in class io.reactivex.rxjava3.observers.DisposableSingleObserver
+
+
Called once the single upstream Disposable is set via DisposableSingleObserver.onSubscribe(Disposable).
+
+
onStart() - Method in class io.reactivex.rxjava3.observers.ResourceCompletableObserver
+
+
Called once the upstream sets a Disposable on this ResourceCompletableObserver.
+
+
onStart() - Method in class io.reactivex.rxjava3.observers.ResourceMaybeObserver
+
+
Called once the upstream sets a Disposable on this ResourceMaybeObserver.
+
+
onStart() - Method in class io.reactivex.rxjava3.observers.ResourceObserver
+
+
Called once the upstream sets a Disposable on this ResourceObserver.
+
+
onStart() - Method in class io.reactivex.rxjava3.observers.ResourceSingleObserver
+
+
Called once the upstream sets a Disposable on this ResourceSingleObserver.
+
+
onStart() - Method in class io.reactivex.rxjava3.subscribers.DefaultSubscriber
+
+
Called once the subscription has been set on this observer; override this + to perform initialization or issue an initial request.
+
+
onStart() - Method in class io.reactivex.rxjava3.subscribers.DisposableSubscriber
+
+
Called once the single upstream Subscription is set via DisposableSubscriber.onSubscribe(Subscription).
+
+
onStart() - Method in class io.reactivex.rxjava3.subscribers.ResourceSubscriber
+
+
Called once the upstream sets a Subscription on this ResourceSubscriber.
+
+
onStart() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
+
Called after the onSubscribe is called and handled.
+
+
onSubscribe(Disposable) - Method in interface io.reactivex.rxjava3.core.CompletableObserver
+
+
Called once by the Completable to set a Disposable on this instance which + then can be used to cancel the subscription at any time.
+
+
onSubscribe(Subscription) - Method in interface io.reactivex.rxjava3.core.FlowableSubscriber
+
+
Implementors of this method should make sure everything that needs + to be visible in Subscriber.onNext(Object) is established before + calling Subscription.request(long).
+
+
onSubscribe(Disposable) - Method in interface io.reactivex.rxjava3.core.MaybeObserver
+
+
Provides the MaybeObserver with the means of cancelling (disposing) the + connection (channel) with the Maybe in both + synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.
+
+
onSubscribe(Disposable) - Method in interface io.reactivex.rxjava3.core.Observer
+
+
Provides the Observer with the means of cancelling (disposing) the + connection (channel) with the Observable in both + synchronous (from within Observer.onNext(Object)) and asynchronous manner.
+
+
onSubscribe(Disposable) - Method in interface io.reactivex.rxjava3.core.SingleObserver
+
+
Provides the SingleObserver with the means of cancelling (disposing) the + connection (channel) with the Single in both + synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.
+
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.DefaultObserver
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.DisposableCompletableObserver
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.DisposableMaybeObserver
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.DisposableObserver
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.DisposableSingleObserver
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceCompletableObserver
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceMaybeObserver
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceObserver
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceSingleObserver
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.SafeObserver
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.SerializedObserver
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.TestObserver
+
 
+
onSubscribe(Flowable<T>, Subscriber<? super T>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onSubscribe(Observable<T>, Observer<? super T>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onSubscribe(Single<T>, SingleObserver<? super T>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onSubscribe(Completable, CompletableObserver) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onSubscribe(Maybe<T>, MaybeObserver<? super T>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onSubscribe(ParallelFlowable<T>, Subscriber<? super T>[]) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Calls the associated hook function.
+
+
onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.processors.AsyncProcessor
+
 
+
onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor
+
 
+
onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
 
+
onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.processors.PublishProcessor
+
 
+
onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
 
+
onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.processors.UnicastProcessor
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.AsyncSubject
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.CompletableSubject
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.MaybeSubject
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.PublishSubject
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.SingleSubject
+
 
+
onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.UnicastSubject
+
 
+
onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.subscribers.DefaultSubscriber
+
 
+
onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.subscribers.DisposableSubscriber
+
 
+
onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.subscribers.ResourceSubscriber
+
 
+
onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.subscribers.SafeSubscriber
+
 
+
onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.subscribers.SerializedSubscriber
+
 
+
onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
 
+
onSuccess(T) - Method in interface io.reactivex.rxjava3.core.MaybeEmitter
+
+
Signal a success value.
+
+
onSuccess(T) - Method in interface io.reactivex.rxjava3.core.MaybeObserver
+
+
Notifies the MaybeObserver with one item and that the Maybe has finished sending + push-based notifications.
+
+
onSuccess(T) - Method in interface io.reactivex.rxjava3.core.SingleEmitter
+
+
Signal a success value.
+
+
onSuccess(T) - Method in interface io.reactivex.rxjava3.core.SingleObserver
+
+
Notifies the SingleObserver with a single item and that the Single has finished sending + push-based notifications.
+
+
onSuccess(T) - Method in class io.reactivex.rxjava3.observers.TestObserver
+
 
+
onSuccess(T) - Method in class io.reactivex.rxjava3.subjects.MaybeSubject
+
 
+
onSuccess(T) - Method in class io.reactivex.rxjava3.subjects.SingleSubject
+
 
+
onTerminateDetach() - Method in class io.reactivex.rxjava3.core.Completable
+
+
Nulls out references to the upstream producer and downstream CompletableObserver if + the sequence is terminated or downstream calls dispose().
+
+
onTerminateDetach() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Nulls out references to the upstream producer and downstream Subscriber if + the sequence is terminated or downstream cancels.
+
+
onTerminateDetach() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Nulls out references to the upstream producer and downstream MaybeObserver if + the sequence is terminated or downstream calls dispose().
+
+
onTerminateDetach() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Nulls out references to the upstream producer and downstream Observer if + the sequence is terminated or downstream calls dispose().
+
+
onTerminateDetach() - Method in class io.reactivex.rxjava3.core.Single
+
+
Nulls out references to the upstream producer and downstream SingleObserver if + the sequence is terminated or downstream calls dispose().
+
+
+ + + +

P

+
+
parallel() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Parallelizes the flow by creating multiple 'rails' (equal to the number of CPUs) + and dispatches the upstream items to them in a round-robin fashion.
+
+
parallel(int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Parallelizes the flow by creating the specified number of 'rails' + and dispatches the upstream items to them in a round-robin fashion.
+
+
parallel(int, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Parallelizes the flow by creating the specified number of 'rails' + and dispatches the upstream items to them in a round-robin fashion and + uses the defined per-'rail' prefetch amount.
+
+
ParallelFailureHandling - Enum in io.reactivex.rxjava3.parallel
+
+
Enumerations for handling failure within a parallel operator.
+
+
ParallelFlowable<T> - Class in io.reactivex.rxjava3.parallel
+
+
Abstract base class for parallel publishing of events signaled to an array of Subscribers.
+
+
ParallelFlowable() - Constructor for class io.reactivex.rxjava3.parallel.ParallelFlowable
+
 
+
ParallelFlowableConverter<T,R> - Interface in io.reactivex.rxjava3.parallel
+
+
Convenience interface and callback used by the ParallelFlowable.to(io.reactivex.rxjava3.parallel.ParallelFlowableConverter<T, R>) operator to turn a ParallelFlowable into + another value fluently.
+
+
parallelism() - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Returns the number of expected parallel Subscribers.
+
+
ParallelTransformer<Upstream,Downstream> - Interface in io.reactivex.rxjava3.parallel
+
+
Interface to compose ParallelFlowable.
+
+
peek() - Method in class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue
+
+
Returns the next element in this queue without removing it or null + if this queue is empty
+
+
poll() - Method in interface io.reactivex.rxjava3.operators.SimplePlainQueue
+
 
+
poll() - Method in interface io.reactivex.rxjava3.operators.SimpleQueue
+
+
Tries to dequeue a value (non-null) or returns null if + the queue is empty.
+
+
poll() - Method in class io.reactivex.rxjava3.operators.SpscArrayQueue
+
 
+
poll() - Method in class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue
+
+
Tries to dequeue a value (non-null) or returns null if + the queue is empty.
+
+
Predicate<T> - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that returns true or false for the given input value.
+
+
printStackTrace() - Method in exception io.reactivex.rxjava3.exceptions.CompositeException
+
+
All of the following printStackTrace functionality is derived from JDK Throwable + printStackTrace.
+
+
printStackTrace(PrintStream) - Method in exception io.reactivex.rxjava3.exceptions.CompositeException
+
 
+
printStackTrace(PrintWriter) - Method in exception io.reactivex.rxjava3.exceptions.CompositeException
+
 
+
propagate(Throwable) - Static method in class io.reactivex.rxjava3.exceptions.Exceptions
+
+
Convenience method to throw a RuntimeException and Error directly + or wrap any other exception type into a RuntimeException.
+
+
ProtocolViolationException - Exception in io.reactivex.rxjava3.exceptions
+
+
Explicitly named exception to indicate a Reactive-Streams + protocol violation.
+
+
ProtocolViolationException(String) - Constructor for exception io.reactivex.rxjava3.exceptions.ProtocolViolationException
+
+
Creates an instance with the given message.
+
+
publish() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a ConnectableFlowable, which is a variety of Publisher that waits until its + connect method is called before it begins emitting items to those + Subscribers that have subscribed to it.
+
+
publish(Function<? super Flowable<T>, ? extends Publisher<R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of invoking a specified selector on items emitted by a + ConnectableFlowable that shares a single subscription to the underlying sequence.
+
+
publish(Function<? super Flowable<T>, ? extends Publisher<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of invoking a specified selector on items emitted by a + ConnectableFlowable that shares a single subscription to the underlying sequence.
+
+
publish(int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a ConnectableFlowable, which is a variety of Publisher that waits until its + connect method is called before it begins emitting items to those + Subscribers that have subscribed to it.
+
+
publish() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a ConnectableObservable, which is a variety of ObservableSource that waits until its + connect method is called before it begins emitting items to those + Observers that have subscribed to it.
+
+
publish(Function<? super Observable<T>, ? extends ObservableSource<R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of invoking a specified selector on items emitted by a + ConnectableObservable that shares a single subscription to the current Observable sequence.
+
+
PublishProcessor<T> - Class in io.reactivex.rxjava3.processors
+
+
Processor that multicasts all subsequently observed items to its current Subscribers.
+
+
PublishSubject<T> - Class in io.reactivex.rxjava3.subjects
+
+
A Subject that emits (multicasts) items to currently subscribed Observers and terminal events to current + or late Observers.
+
+
+ + + +

Q

+
+
QueueDisposable<T> - Interface in io.reactivex.rxjava3.operators
+
+
An interface extending SimpleQueue and Disposable and allows negotiating + the fusion mode between subsequent operators of the Observable base reactive type.
+
+
QueueFuseable<T> - Interface in io.reactivex.rxjava3.operators
+
+
Represents a SimpleQueue plus the means and constants for requesting a fusion mode.
+
+
QueueOverflowException - Exception in io.reactivex.rxjava3.exceptions
+
+
Indicates an overflow happened because the upstream disregarded backpressure completely or + Subscriber.onNext(Object) was called concurrently from multiple threads + without synchronization.
+
+
QueueOverflowException() - Constructor for exception io.reactivex.rxjava3.exceptions.QueueOverflowException
+
+
Constructs a QueueOverflowException with the default message.
+
+
QueueOverflowException(String) - Constructor for exception io.reactivex.rxjava3.exceptions.QueueOverflowException
+
+
Constructs a QueueOverflowException with the given message but no cause.
+
+
QueueSubscription<T> - Interface in io.reactivex.rxjava3.operators
+
+
An interface extending SimpleQueue and Subscription and allows negotiating + the fusion mode between subsequent operators of the Flowable base reactive type.
+
+
+ + + +

R

+
+
range(int, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits a sequence of Integers within a specified range.
+
+
range(int, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits a sequence of Integers within a specified range.
+
+
rangeLong(long, long) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits a sequence of Longs within a specified range.
+
+
rangeLong(long, long) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits a sequence of Longs within a specified range.
+
+
rebatchRequests(int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Requests n initially from the upstream and then 75% of n subsequently + after 75% of n values have been emitted to the downstream.
+
+
reduce(BiFunction<T, T, T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Maybe that applies a specified accumulator function to the first item emitted by the current + Flowable, then feeds the result of that function along with the second item emitted by the current + Flowable into the same function, and so on until all items have been emitted by the current and finite Flowable, + and emits the final result from the final call to your function as its sole item.
+
+
reduce(R, BiFunction<R, ? super T, R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that applies a specified accumulator function to the first item emitted by the current + Flowable and a specified seed value, then feeds the result of that function along with the second item + emitted by the current Flowable into the same function, and so on until all items have been emitted by the + current and finite Flowable, emitting the final result from the final call to your function as its sole item.
+
+
reduce(BiFunction<T, T, T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Maybe that applies a specified accumulator function to the first item emitted by the current + Observable, then feeds the result of that function along with the second item emitted by the current + Observable into the same function, and so on until all items have been emitted by the current and finite Observable, + and emits the final result from the final call to your function as its sole item.
+
+
reduce(R, BiFunction<R, ? super T, R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that applies a specified accumulator function to the first item emitted by the current + Observable and a specified seed value, then feeds the result of that function along with the second item + emitted by the current Observable into the same function, and so on until all items have been emitted by the + current and finite Observable, emitting the final result from the final call to your function as its sole item.
+
+
reduce(BiFunction<T, T, T>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Reduces all values within a 'rail' and across 'rails' with a reducer function into one + Flowable sequence.
+
+
reduce(Supplier<R>, BiFunction<R, ? super T, R>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Reduces all values within a 'rail' to a single value (with a possibly different type) via + a reducer function that is initialized on each rail from an initialSupplier value.
+
+
reduceWith(Supplier<R>, BiFunction<R, ? super T, R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that applies a specified accumulator function to the first item emitted by the current + Flowable and a seed value derived from calling a specified seedSupplier, then feeds the result + of that function along with the second item emitted by the current Flowable into the same function, and so on until + all items have been emitted by the current and finite Flowable, emitting the final result from the final call to your + function as its sole item.
+
+
reduceWith(Supplier<R>, BiFunction<R, ? super T, R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that applies a specified accumulator function to the first item emitted by the current + Observable and a seed value derived from calling a specified seedSupplier, then feeds the result + of that function along with the second item emitted by the current Observable into the same function, + and so on until all items have been emitted by the current and finite Observable, emitting the final result + from the final call to your function as its sole item.
+
+
refCount() - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable
+
+
Returns a Flowable that stays connected to this ConnectableFlowable as long as there + is at least one subscription to this ConnectableFlowable.
+
+
refCount(int) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable
+
+
Connects to the upstream ConnectableFlowable if the number of subscribed + subscriber reaches the specified count and disconnect if all subscribers have unsubscribed.
+
+
refCount(long, TimeUnit) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable
+
+
Connects to the upstream ConnectableFlowable if the number of subscribed + subscriber reaches 1 and disconnect after the specified + timeout if all subscribers have unsubscribed.
+
+
refCount(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable
+
+
Connects to the upstream ConnectableFlowable if the number of subscribed + subscriber reaches 1 and disconnect after the specified + timeout if all subscribers have unsubscribed.
+
+
refCount(int, long, TimeUnit) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable
+
+
Connects to the upstream ConnectableFlowable if the number of subscribed + subscriber reaches the specified count and disconnect after the specified + timeout if all subscribers have unsubscribed.
+
+
refCount(int, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable
+
+
Connects to the upstream ConnectableFlowable if the number of subscribed + subscriber reaches the specified count and disconnect after the specified + timeout if all subscribers have unsubscribed.
+
+
refCount() - Method in class io.reactivex.rxjava3.observables.ConnectableObservable
+
+
Returns an Observable that stays connected to this ConnectableObservable as long as there + is at least one subscription to this ConnectableObservable.
+
+
refCount(int) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable
+
+
Connects to the upstream ConnectableObservable if the number of subscribed + observers reaches the specified count and disconnect if all Observers have unsubscribed.
+
+
refCount(long, TimeUnit) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable
+
+
Connects to the upstream ConnectableObservable if the number of subscribed + observers reaches 1 and disconnect after the specified + timeout if all Observers have unsubscribed.
+
+
refCount(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable
+
+
Connects to the upstream ConnectableObservable if the number of subscribed + observers reaches 1 and disconnect after the specified + timeout if all Observers have unsubscribed.
+
+
refCount(int, long, TimeUnit) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable
+
+
Connects to the upstream ConnectableObservable if the number of subscribed + observers reaches the specified count and disconnect after the specified + timeout if all Observers have unsubscribed.
+
+
refCount(int, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable
+
+
Connects to the upstream ConnectableObservable if the number of subscribed + observers reaches the specified count and disconnect after the specified + timeout if all Observers have unsubscribed.
+
+
remove(Disposable) - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable
+
+
Removes and disposes the given Disposable if it is part of this + container.
+
+
remove(Disposable) - Method in interface io.reactivex.rxjava3.disposables.DisposableContainer
+
+
Removes and disposes the given disposable if it is part of this + container.
+
+
repeat() - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that repeatedly subscribes to this Completable until disposed.
+
+
repeat(long) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that subscribes repeatedly at most the given number of times to this Completable.
+
+
repeat() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that repeats the sequence of items emitted by the current Flowable indefinitely.
+
+
repeat(long) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that repeats the sequence of items emitted by the current Flowable at most + count times.
+
+
repeat() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Flowable that repeats the sequence of items emitted by the current Maybe indefinitely.
+
+
repeat(long) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Flowable that repeats the sequence of items emitted by the current Maybe at most + count times.
+
+
repeat() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that repeats the sequence of items emitted by the current Observable indefinitely.
+
+
repeat(long) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that repeats the sequence of items emitted by the current Observable at most + count times.
+
+
repeat() - Method in class io.reactivex.rxjava3.core.Single
+
+
Repeatedly re-subscribes to the current Single and emits each success value as a Flowable sequence.
+
+
repeat(long) - Method in class io.reactivex.rxjava3.core.Single
+
+
Re-subscribes to the current Single at most the given number of times and emits each success value as a Flowable sequence.
+
+
repeatUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that repeatedly subscribes to this Completable so long as the given + stop BooleanSupplier returns false.
+
+
repeatUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that repeats the sequence of items emitted by the current Flowable until + the provided stop function returns true.
+
+
repeatUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Flowable that repeats the sequence of items emitted by the current Maybe until + the provided stop function returns true.
+
+
repeatUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that repeats the sequence of items emitted by the current Observable until + the provided stop function returns true.
+
+
repeatUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Single
+
+
Re-subscribes to the current Single until the given BooleanSupplier returns true + and emits the success items as a Flowable sequence.
+
+
repeatWhen(Function<? super Flowable<Object>, ? extends Publisher<?>>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that repeats when the Publisher returned by the handler Function + emits an item or completes when this Publisher emits an onComplete event.
+
+
repeatWhen(Function<? super Flowable<Object>, ? extends Publisher<?>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the same values as the current Flowable with the exception of an + onComplete.
+
+
repeatWhen(Function<? super Flowable<Object>, ? extends Publisher<?>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Flowable that emits the same values as the current Maybe with the exception of an + onComplete.
+
+
repeatWhen(Function<? super Observable<Object>, ? extends ObservableSource<?>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the same values as the current Observable with the exception of an + onComplete.
+
+
repeatWhen(Function<? super Flowable<Object>, ? extends Publisher<?>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Re-subscribes to the current Single if + the Publisher returned by the handler function signals a value in response to a + value signaled through the Flowable the handler receives.
+
+
replace(Disposable) - Method in class io.reactivex.rxjava3.disposables.SerialDisposable
+
+
Atomically: set the next disposable on this container but don't dispose the previous + one (if any) or dispose next if the container has been disposed.
+
+
replay() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a ConnectableFlowable that shares a single subscription to the underlying Publisher + that will replay all of its items and notifications to any future Subscriber.
+
+
replay(Function<? super Flowable<T>, ? extends Publisher<R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items that are the results of invoking a specified selector on the items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable.
+
+
replay(Function<? super Flowable<T>, ? extends Publisher<R>>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying bufferSize notifications.
+
+
replay(Function<? super Flowable<T>, ? extends Publisher<R>>, int, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying bufferSize notifications.
+
+
replay(Function<? super Flowable<T>, ? extends Publisher<R>>, int, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying no more than bufferSize items that were emitted within a specified time window.
+
+
replay(Function<? super Flowable<T>, ? extends Publisher<R>>, int, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying no more than bufferSize items that were emitted within a specified time window.
+
+
replay(Function<? super Flowable<T>, ? extends Publisher<R>>, int, long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying no more than bufferSize items that were emitted within a specified time window.
+
+
replay(Function<? super Flowable<T>, ? extends Publisher<R>>, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying all items that were emitted within a specified time window.
+
+
replay(Function<? super Flowable<T>, ? extends Publisher<R>>, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying all items that were emitted within a specified time window.
+
+
replay(Function<? super Flowable<T>, ? extends Publisher<R>>, long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying all items that were emitted within a specified time window.
+
+
replay(int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a ConnectableFlowable that shares a single subscription to the current Flowable and + replays at most bufferSize items to late Subscribers.
+
+
replay(int, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a ConnectableFlowable that shares a single subscription to the current Flowable and + replays at most bufferSize items to late Subscribers.
+
+
replay(int, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a ConnectableFlowable that shares a single subscription to the current Flowable and + replays at most bufferSize items that were emitted during a specified time window.
+
+
replay(int, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a ConnectableFlowable that shares a single subscription to the current Flowable and + replays a maximum of bufferSize items that are emitted within a specified time window to late Subscribers.
+
+
replay(int, long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a ConnectableFlowable that shares a single subscription to the current Flowable and + replays a maximum of bufferSize items that are emitted within a specified time window to late Subscribers.
+
+
replay(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a ConnectableFlowable that shares a single subscription to the current Flowable and + replays all items emitted by it within a specified time window to late Subscribers.
+
+
replay(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a ConnectableFlowable that shares a single subscription to the current Flowable and + replays all items emitted by it within a specified time window to late Subscribers.
+
+
replay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a ConnectableFlowable that shares a single subscription to the current Flowable and + replays all items emitted by it within a specified time window to late Subscribers.
+
+
replay() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a ConnectableObservable that shares a single subscription to the current Observable + that will replay all of its items and notifications to any future Observer.
+
+
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items that are the results of invoking a specified selector on the items + emitted by a ConnectableObservable that shares a single subscription to the current Observable.
+
+
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableObservable that shares a single subscription to the current Observable, + replaying bufferSize notifications.
+
+
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>, int, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableObservable that shares a single subscription to the current Observable, + replaying bufferSize notifications.
+
+
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>, int, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableObservable that shares a single subscription to the current Observable, + replaying no more than bufferSize items that were emitted within a specified time window.
+
+
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>, int, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableObservable that shares a single subscription to the current Observable, + replaying no more than bufferSize items that were emitted within a specified time window.
+
+
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>, int, long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableObservable that shares a single subscription to the current Observable, + replaying no more than bufferSize items that were emitted within a specified time window.
+
+
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableObservable that shares a single subscription to the current Observable, + replaying all items that were emitted within a specified time window.
+
+
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableObservable that shares a single subscription to the current Observable, + replaying all items that were emitted within a specified time window.
+
+
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>, long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableObservable that shares a single subscription to the current Observable, + replaying all items that were emitted within a specified time window.
+
+
replay(int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a ConnectableObservable that shares a single subscription to the current Observable that + replays at most bufferSize items emitted by the current Observable.
+
+
replay(int, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a ConnectableObservable that shares a single subscription to the current Observable that + replays at most bufferSize items emitted by the current Observable.
+
+
replay(int, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a ConnectableObservable that shares a single subscription to the current Observable and + replays at most bufferSize items that were emitted during a specified time window.
+
+
replay(int, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a ConnectableObservable that shares a single subscription to the current Observable and + that replays a maximum of bufferSize items that are emitted within a specified time window.
+
+
replay(int, long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a ConnectableObservable that shares a single subscription to the current Observable and + that replays a maximum of bufferSize items that are emitted within a specified time window.
+
+
replay(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a ConnectableObservable that shares a single subscription to the current Observable and + replays all items emitted by the current Observable within a specified time window.
+
+
replay(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a ConnectableObservable that shares a single subscription to the current Observable and + replays all items emitted by the current Observable within a specified time window.
+
+
replay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a ConnectableObservable that shares a single subscription to the current Observable and + replays all items emitted by the current Observable within a specified time window.
+
+
ReplayProcessor<T> - Class in io.reactivex.rxjava3.processors
+
+
Replays events to Subscribers.
+
+
ReplaySubject<T> - Class in io.reactivex.rxjava3.subjects
+
+
Replays events (in a configurable bounded or unbounded manner) to current and late Observers.
+
+
request(long) - Method in class io.reactivex.rxjava3.subscribers.DefaultSubscriber
+
+
Requests from the upstream Subscription.
+
+
request(long) - Method in class io.reactivex.rxjava3.subscribers.DisposableSubscriber
+
+
Requests the specified amount from the upstream if its Subscription is set via + onSubscribe already.
+
+
request(long) - Method in class io.reactivex.rxjava3.subscribers.ResourceSubscriber
+
+
Request the specified amount of elements from upstream.
+
+
request(long) - Method in class io.reactivex.rxjava3.subscribers.SafeSubscriber
+
 
+
request(long) - Method in class io.reactivex.rxjava3.subscribers.SerializedSubscriber
+
 
+
request(long) - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
 
+
requested() - Method in interface io.reactivex.rxjava3.core.FlowableEmitter
+
+
The current outstanding request amount.
+
+
requestFusion(int) - Method in interface io.reactivex.rxjava3.operators.QueueFuseable
+
+
Request a fusion mode from the upstream.
+
+
requestMore(long) - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber
+
+
Calls TestSubscriber.request(long) and returns this.
+
+
reset() - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable
+
+
Resets this ConnectableFlowable into its fresh state if it has terminated.
+
+
reset() - Method in class io.reactivex.rxjava3.observables.ConnectableObservable
+
+
Resets this ConnectableObservable into its fresh state if it has terminated + or has been disposed.
+
+
reset() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Removes all handlers and resets to default behavior.
+
+
ResourceCompletableObserver - Class in io.reactivex.rxjava3.observers
+
+
An abstract CompletableObserver that allows asynchronous cancellation of its subscription and associated resources.
+
+
ResourceCompletableObserver() - Constructor for class io.reactivex.rxjava3.observers.ResourceCompletableObserver
+
 
+
ResourceMaybeObserver<T> - Class in io.reactivex.rxjava3.observers
+
+
An abstract MaybeObserver that allows asynchronous cancellation of its subscription and associated resources.
+
+
ResourceMaybeObserver() - Constructor for class io.reactivex.rxjava3.observers.ResourceMaybeObserver
+
 
+
ResourceObserver<T> - Class in io.reactivex.rxjava3.observers
+
+
An abstract Observer that allows asynchronous cancellation of its subscription and associated resources.
+
+
ResourceObserver() - Constructor for class io.reactivex.rxjava3.observers.ResourceObserver
+
 
+
ResourceSingleObserver<T> - Class in io.reactivex.rxjava3.observers
+
+
An abstract SingleObserver that allows asynchronous cancellation of its subscription + and the associated resources.
+
+
ResourceSingleObserver() - Constructor for class io.reactivex.rxjava3.observers.ResourceSingleObserver
+
 
+
ResourceSubscriber<T> - Class in io.reactivex.rxjava3.subscribers
+
+
An abstract Subscriber that allows asynchronous cancellation of its + subscription and associated resources.
+
+
ResourceSubscriber() - Constructor for class io.reactivex.rxjava3.subscribers.ResourceSubscriber
+
 
+
retry() - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that retries this Completable as long as it emits an onError event.
+
+
retry(BiPredicate<? super Integer, ? super Throwable>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that retries this Completable in case of an error as long as the predicate + returns true.
+
+
retry(long) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that when this Completable emits an error, retries at most the given + number of times before giving up and emitting the last error.
+
+
retry(long, Predicate<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that when this Completable emits an error, retries at most times + or until the predicate returns false, whichever happens first and emitting the last error.
+
+
retry(Predicate<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that when this Completable emits an error, calls the given predicate with + the latest Throwable to decide whether to resubscribe to the upstream or not.
+
+
retry() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable, resubscribing to it if it calls onError + (infinite retry count).
+
+
retry(BiPredicate<? super Integer, ? super Throwable>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable, resubscribing to it if it calls onError + and the predicate returns true for that specific exception and retry count.
+
+
retry(long) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable, resubscribing to it if it calls onError + up to a specified number of retries.
+
+
retry(long, Predicate<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Retries at most times or until the predicate returns false, whichever happens first.
+
+
retry(Predicate<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Retries the current Flowable if the predicate returns true.
+
+
retry() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that mirrors the current Maybe, resubscribing to it if it calls onError + (infinite retry count).
+
+
retry(BiPredicate<? super Integer, ? super Throwable>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that mirrors the current Maybe, resubscribing to it if it calls onError + and the predicate returns true for that specific exception and retry count.
+
+
retry(long) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that mirrors the current Maybe, resubscribing to it if it calls onError + up to a specified number of retries.
+
+
retry(long, Predicate<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Retries at most times or until the predicate returns false, whichever happens first.
+
+
retry(Predicate<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Retries the current Maybe if it fails and the predicate returns true.
+
+
retry() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable, resubscribing to it if it calls onError + (infinite retry count).
+
+
retry(BiPredicate<? super Integer, ? super Throwable>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable, resubscribing to it if it calls onError + and the predicate returns true for that specific exception and retry count.
+
+
retry(long) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable, resubscribing to it if it calls onError + up to a specified number of retries.
+
+
retry(long, Predicate<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Retries at most times or until the predicate returns false, whichever happens first.
+
+
retry(Predicate<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Retries the current Observable if the predicate returns true.
+
+
retry() - Method in class io.reactivex.rxjava3.core.Single
+
+
Repeatedly re-subscribes to the current Single indefinitely if it fails with an onError.
+
+
retry(long) - Method in class io.reactivex.rxjava3.core.Single
+
+
Repeatedly re-subscribe at most the specified times to the current Single + if it fails with an onError.
+
+
retry(BiPredicate<? super Integer, ? super Throwable>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Re-subscribe to the current Single if the given predicate returns true when the Single fails + with an onError.
+
+
retry(long, Predicate<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Repeatedly re-subscribe at most times or until the predicate returns false, whichever happens first + if it fails with an onError.
+
+
retry(Predicate<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Re-subscribe to the current Single if the given predicate returns true when the Single fails + with an onError.
+
+
retryUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Retries until the given stop function returns true.
+
+
retryUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Retries until the given stop function returns true.
+
+
retryUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Retries until the given stop function returns true.
+
+
retryUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Retries until the given stop function returns true.
+
+
retryUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Single
+
+
Retries until the given stop function returns true.
+
+
retryWhen(Function<? super Flowable<Throwable>, ? extends Publisher<?>>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which given a Publisher and when this Completable emits an error, delivers + that error through a Flowable and the Publisher should signal a value indicating a retry in response + or a terminal event indicating a termination.
+
+
retryWhen(Function<? super Flowable<Throwable>, ? extends Publisher<?>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the same values as the current Flowable with the exception of an + onError.
+
+
retryWhen(Function<? super Flowable<Throwable>, ? extends Publisher<?>>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits the same values as the current Maybe with the exception of an + onError.
+
+
retryWhen(Function<? super Observable<Throwable>, ? extends ObservableSource<?>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the same values as the current Observable with the exception of an + onError.
+
+
retryWhen(Function<? super Flowable<Throwable>, ? extends Publisher<?>>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Re-subscribes to the current Single if and when the Publisher returned by the handler + function signals a value.
+
+
run() - Method in interface io.reactivex.rxjava3.functions.Action
+
+
Runs the action and optionally throws a checked exception.
+
+
runOn(Scheduler) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Specifies where each 'rail' will observe its incoming values, specified via a Scheduler, with + no work-stealing and default prefetch amount.
+
+
runOn(Scheduler, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Specifies where each 'rail' will observe its incoming values, specified via a Scheduler, with + possibly work-stealing and a given prefetch amount.
+
+
RxJavaPlugins - Class in io.reactivex.rxjava3.plugins
+
+
Utility class to inject handlers to certain standard RxJava operations.
+
+
+ + + +

S

+
+
SafeObserver<T> - Class in io.reactivex.rxjava3.observers
+
+
Wraps another Observer and ensures all onXXX methods conform the protocol + (except the requirement for serialized access).
+
+
SafeObserver(Observer<? super T>) - Constructor for class io.reactivex.rxjava3.observers.SafeObserver
+
+
Constructs a SafeObserver by wrapping the given actual Observer.
+
+
safeSubscribe(CompletableObserver) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Wraps the given CompletableObserver, catches any RuntimeExceptions thrown by its + CompletableObserver.onSubscribe(Disposable), CompletableObserver.onError(Throwable) + or CompletableObserver.onComplete() methods and routes those to the global + error handler via RxJavaPlugins.onError(Throwable).
+
+
safeSubscribe(Subscriber<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the current Flowable and wraps the given Subscriber into a SafeSubscriber + (if not already a SafeSubscriber) that + deals with exceptions thrown by a misbehaving Subscriber (that doesn't follow the + Reactive Streams specification).
+
+
safeSubscribe(MaybeObserver<? super T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Wraps the given MaybeObserver, catches any RuntimeExceptions thrown by its + MaybeObserver.onSubscribe(Disposable), MaybeObserver.onSuccess(Object), + MaybeObserver.onError(Throwable) or MaybeObserver.onComplete() methods + and routes those to the global error handler via RxJavaPlugins.onError(Throwable).
+
+
safeSubscribe(Observer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Subscribes to the current Observable and wraps the given Observer into a SafeObserver + (if not already a SafeObserver) that + deals with exceptions thrown by a misbehaving Observer (that doesn't follow the + Reactive Streams specification).
+
+
safeSubscribe(SingleObserver<? super T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Wraps the given SingleObserver, catches any RuntimeExceptions thrown by its + SingleObserver.onSubscribe(Disposable), SingleObserver.onSuccess(Object) or + SingleObserver.onError(Throwable) methods* and routes those to the global error handler + via RxJavaPlugins.onError(Throwable).
+
+
SafeSubscriber<T> - Class in io.reactivex.rxjava3.subscribers
+
+
Wraps another Subscriber and ensures all onXXX methods conform the protocol + (except the requirement for serialized access).
+
+
SafeSubscriber(Subscriber<? super T>) - Constructor for class io.reactivex.rxjava3.subscribers.SafeSubscriber
+
+
Constructs a SafeSubscriber by wrapping the given actual Subscriber.
+
+
sample(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable + within periodic time intervals.
+
+
sample(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable + within periodic time intervals and optionally emit the very last upstream item when the upstream completes.
+
+
sample(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable + within periodic time intervals, where the intervals are defined on a particular Scheduler.
+
+
sample(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable + within periodic time intervals, where the intervals are defined on a particular Scheduler + and optionally emit the very last upstream item when the upstream completes.
+
+
sample(long, TimeUnit, Scheduler, boolean, Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable + within periodic time intervals, where the intervals are defined on a particular Scheduler + and optionally emit the very last upstream item when the upstream completes.
+
+
sample(Publisher<U>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that, when the specified sampler Publisher emits an item or completes, + emits the most recently emitted item (if any) emitted by the current Flowable since the previous + emission from the sampler Publisher.
+
+
sample(Publisher<U>, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that, when the specified sampler Publisher emits an item or completes, + emits the most recently emitted item (if any) emitted by the current Flowable since the previous + emission from the sampler Publisher + and optionally emit the very last upstream item when the upstream or other Publisher complete.
+
+
sample(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable + within periodic time intervals.
+
+
sample(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable + within periodic time intervals and optionally emit the very last upstream item when the upstream completes.
+
+
sample(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable + within periodic time intervals, where the intervals are defined on a particular Scheduler.
+
+
sample(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable + within periodic time intervals, where the intervals are defined on a particular Scheduler + and optionally emit the very last upstream item when the upstream completes.
+
+
sample(long, TimeUnit, Scheduler, boolean, Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable + within periodic time intervals, where the intervals are defined on a particular Scheduler.
+
+
sample(ObservableSource<U>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that, when the specified sampler ObservableSource emits an item or completes, + emits the most recently emitted item (if any) emitted by the current Observable since the previous + emission from the sampler ObservableSource.
+
+
sample(ObservableSource<U>, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that, when the specified sampler ObservableSource emits an item or completes, + emits the most recently emitted item (if any) emitted by the current Observable since the previous + emission from the sampler ObservableSource + and optionally emit the very last upstream item when the upstream or other ObservableSource complete.
+
+
ScalarSupplier<T> - Interface in io.reactivex.rxjava3.operators
+
+
A marker interface indicating that a scalar, constant value + is held by the implementing reactive type which can be + safely extracted during assembly time can be used for + optimization.
+
+
scan(BiFunction<T, T, T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the first value emitted by the current Flowable, then emits one value + for each subsequent value emitted by the current Flowable.
+
+
scan(R, BiFunction<R, ? super T, R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the provided initial (seed) value, then emits one value for each value emitted + by the current Flowable.
+
+
scan(BiFunction<T, T, T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the first value emitted by the current Observable, then emits one value + for each subsequent value emitted by the current Observable.
+
+
scan(R, BiFunction<R, ? super T, R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the provided initial (seed) value, then emits one value for each value emitted + by the current Observable.
+
+
scanWith(Supplier<R>, BiFunction<R, ? super T, R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the provided initial (seed) value, then emits one value for each value emitted + by the current Flowable.
+
+
scanWith(Supplier<R>, BiFunction<R, ? super T, R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the provided initial (seed) value, then emits one value for each value emitted + by the current Observable.
+
+
schedule(Runnable) - Method in class io.reactivex.rxjava3.core.Scheduler.Worker
+
+
Schedules a Runnable for execution without any time delay.
+
+
schedule(Runnable, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Scheduler.Worker
+
+
Schedules an Runnable for execution at some point in the future specified by a time delay + relative to the current time.
+
+
scheduleDirect(Runnable) - Method in class io.reactivex.rxjava3.core.Scheduler
+
+
Schedules the given task on this Scheduler without any time delay.
+
+
scheduleDirect(Runnable, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Scheduler
+
+
Schedules the execution of the given task with the given time delay.
+
+
schedulePeriodically(Runnable, long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Scheduler.Worker
+
+
Schedules a periodic execution of the given task with the given initial time delay and repeat period.
+
+
schedulePeriodicallyDirect(Runnable, long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Scheduler
+
+
Schedules a periodic execution of the given task with the given initial time delay and repeat period.
+
+
Scheduler - Class in io.reactivex.rxjava3.core
+
+
A Scheduler is an object that specifies an API for scheduling + units of work provided in the form of Runnables to be + executed without delay (effectively as soon as possible), after a specified time delay or periodically + and represents an abstraction over an asynchronous boundary that ensures + these units of work get executed by some underlying task-execution scheme + (such as custom Threads, event loop, Executor or Actor system) + with some uniform properties and guarantees regardless of the particular underlying + scheme.
+
+
Scheduler() - Constructor for class io.reactivex.rxjava3.core.Scheduler
+
 
+
Scheduler.Worker - Class in io.reactivex.rxjava3.core
+
+
Represents an isolated, sequential worker of a parent Scheduler for executing Runnable tasks on + an underlying task-execution scheme (such as custom Threads, event loop, Executor or Actor system).
+
+
SchedulerRunnableIntrospection - Interface in io.reactivex.rxjava3.schedulers
+
+
Interface to indicate the implementor class wraps a Runnable that can + be accessed via SchedulerRunnableIntrospection.getWrappedRunnable().
+
+
Schedulers - Class in io.reactivex.rxjava3.schedulers
+
+
Static factory methods for returning standard Scheduler instances.
+
+
SchedulerSupport - Annotation Type in io.reactivex.rxjava3.annotations
+
+
Indicates what kind of scheduler the class or method uses.
+
+
sequenceEqual(CompletableSource, CompletableSource) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Compares two CompletableSources and emits true via a Single if both complete.
+
+
sequenceEqual(Publisher<? extends T>, Publisher<? extends T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the + same by comparing the items emitted by each Publisher pairwise.
+
+
sequenceEqual(Publisher<? extends T>, Publisher<? extends T>, BiPredicate<? super T, ? super T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the + same by comparing the items emitted by each Publisher pairwise based on the results of a specified + equality function.
+
+
sequenceEqual(Publisher<? extends T>, Publisher<? extends T>, BiPredicate<? super T, ? super T>, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the + same by comparing the items emitted by each Publisher pairwise based on the results of a specified + equality function.
+
+
sequenceEqual(Publisher<? extends T>, Publisher<? extends T>, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the + same by comparing the items emitted by each Publisher pairwise.
+
+
sequenceEqual(MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Single that emits a Boolean value that indicates whether two MaybeSource sequences are the + same by comparing the items emitted by each MaybeSource pairwise.
+
+
sequenceEqual(MaybeSource<? extends T>, MaybeSource<? extends T>, BiPredicate<? super T, ? super T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Single that emits a Boolean value that indicates whether two MaybeSources are the + same by comparing the items emitted by each MaybeSource pairwise based on the results of a specified + equality function.
+
+
sequenceEqual(ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the + same by comparing the items emitted by each ObservableSource pairwise.
+
+
sequenceEqual(ObservableSource<? extends T>, ObservableSource<? extends T>, BiPredicate<? super T, ? super T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the + same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified + equality function.
+
+
sequenceEqual(ObservableSource<? extends T>, ObservableSource<? extends T>, BiPredicate<? super T, ? super T>, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the + same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified + equality function.
+
+
sequenceEqual(ObservableSource<? extends T>, ObservableSource<? extends T>, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the + same by comparing the items emitted by each ObservableSource pairwise.
+
+
sequenceEqual(SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Compares two SingleSources and emits true if they emit the same value (compared via Object.equals(Object)).
+
+
sequential() - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Merges the values from each 'rail' in a round-robin or same-order fashion and + exposes it as a regular Flowable sequence, running with a default prefetch value + for the rails.
+
+
sequential(int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Merges the values from each 'rail' in a round-robin or same-order fashion and + exposes it as a regular Flowable sequence, running with a give prefetch value + for the rails.
+
+
sequentialDelayError() - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Merges the values from each 'rail' in a round-robin or same-order fashion and + exposes it as a regular Flowable sequence, running with a default prefetch value + for the rails and delaying errors from all rails till all terminate.
+
+
sequentialDelayError(int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Merges the values from each 'rail' in a round-robin or same-order fashion and + exposes it as a regular Flowable sequence, running with a give prefetch value + for the rails and delaying errors from all rails till all terminate.
+
+
SerialDisposable - Class in io.reactivex.rxjava3.disposables
+
+
A Disposable container that allows atomically updating/replacing the contained + Disposable with another Disposable, disposing the old one when updating plus + handling the disposition when the container itself is disposed.
+
+
SerialDisposable() - Constructor for class io.reactivex.rxjava3.disposables.SerialDisposable
+
+
Constructs an empty SerialDisposable.
+
+
SerialDisposable(Disposable) - Constructor for class io.reactivex.rxjava3.disposables.SerialDisposable
+
+
Constructs a SerialDisposable with the given initial Disposable instance.
+
+
serialize() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Forces the current Flowable's emissions and notifications to be serialized and for it to obey + the Publisher contract in other ways.
+
+
serialize() - Method in interface io.reactivex.rxjava3.core.FlowableEmitter
+
+
Ensures that calls to onNext, onError and onComplete are properly serialized.
+
+
serialize() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Forces the current Observable's emissions and notifications to be serialized and for it to obey + the ObservableSource contract in other ways.
+
+
serialize() - Method in interface io.reactivex.rxjava3.core.ObservableEmitter
+
+
Ensures that calls to onNext, onError and onComplete are properly serialized.
+
+
SerializedObserver<T> - Class in io.reactivex.rxjava3.observers
+
+
Serializes access to the Observer.onNext(Object), Observer.onError(Throwable) and + Observer.onComplete() methods of another Observer.
+
+
SerializedObserver(Observer<? super T>) - Constructor for class io.reactivex.rxjava3.observers.SerializedObserver
+
+
Construct a SerializedObserver by wrapping the given actual Observer.
+
+
SerializedObserver(Observer<? super T>, boolean) - Constructor for class io.reactivex.rxjava3.observers.SerializedObserver
+
+
Construct a SerializedObserver by wrapping the given actual Observer and + optionally delaying the errors till all regular values have been emitted + from the internal buffer.
+
+
SerializedSubscriber<T> - Class in io.reactivex.rxjava3.subscribers
+
+
Serializes access to the Subscriber.onNext(Object), Subscriber.onError(Throwable) and + Subscriber.onComplete() methods of another Subscriber.
+
+
SerializedSubscriber(Subscriber<? super T>) - Constructor for class io.reactivex.rxjava3.subscribers.SerializedSubscriber
+
+
Construct a SerializedSubscriber by wrapping the given actual Subscriber.
+
+
SerializedSubscriber(Subscriber<? super T>, boolean) - Constructor for class io.reactivex.rxjava3.subscribers.SerializedSubscriber
+
+
Construct a SerializedSubscriber by wrapping the given actual Subscriber and + optionally delaying the errors till all regular values have been emitted + from the internal buffer.
+
+
set(Disposable) - Method in class io.reactivex.rxjava3.disposables.SerialDisposable
+
+
Atomically: set the next disposable on this container and dispose the previous + one (if any) or dispose next if the container has been disposed.
+
+
setCancellable(Cancellable) - Method in interface io.reactivex.rxjava3.core.CompletableEmitter
+
+
Sets a Cancellable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled.
+
+
setCancellable(Cancellable) - Method in interface io.reactivex.rxjava3.core.FlowableEmitter
+
+
Sets a Cancellable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled.
+
+
setCancellable(Cancellable) - Method in interface io.reactivex.rxjava3.core.MaybeEmitter
+
+
Sets a Cancellable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled.
+
+
setCancellable(Cancellable) - Method in interface io.reactivex.rxjava3.core.ObservableEmitter
+
+
Sets a Cancellable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled.
+
+
setCancellable(Cancellable) - Method in interface io.reactivex.rxjava3.core.SingleEmitter
+
+
Sets a Cancellable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled.
+
+
setComputationSchedulerHandler(Function<? super Scheduler, ? extends Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setDisposable(Disposable) - Method in interface io.reactivex.rxjava3.core.CompletableEmitter
+
+
Sets a Disposable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled.
+
+
setDisposable(Disposable) - Method in interface io.reactivex.rxjava3.core.FlowableEmitter
+
+
Sets a Disposable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled.
+
+
setDisposable(Disposable) - Method in interface io.reactivex.rxjava3.core.MaybeEmitter
+
+
Sets a Disposable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled.
+
+
setDisposable(Disposable) - Method in interface io.reactivex.rxjava3.core.ObservableEmitter
+
+
Sets a Disposable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled.
+
+
setDisposable(Disposable) - Method in interface io.reactivex.rxjava3.core.SingleEmitter
+
+
Sets a Disposable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled.
+
+
setErrorHandler(Consumer<? super Throwable>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setFailOnNonBlockingScheduler(boolean) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Enables or disables the blockingX operators to fail + with an IllegalStateException on a non-blocking + scheduler such as computation or single.
+
+
setInitComputationSchedulerHandler(Function<? super Supplier<Scheduler>, ? extends Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setInitIoSchedulerHandler(Function<? super Supplier<Scheduler>, ? extends Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setInitNewThreadSchedulerHandler(Function<? super Supplier<Scheduler>, ? extends Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setInitSingleSchedulerHandler(Function<? super Supplier<Scheduler>, ? extends Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setIoSchedulerHandler(Function<? super Scheduler, ? extends Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setNewThreadSchedulerHandler(Function<? super Scheduler, ? extends Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setOnBeforeBlocking(BooleanSupplier) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Set the handler that is called when an operator attempts a blocking + await; the handler should return true to prevent the blocking + and to signal an IllegalStateException instead.
+
+
setOnCompletableAssembly(Function<? super Completable, ? extends Completable>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setOnCompletableSubscribe(BiFunction<? super Completable, ? super CompletableObserver, ? extends CompletableObserver>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setOnConnectableFlowableAssembly(Function<? super ConnectableFlowable, ? extends ConnectableFlowable>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setOnConnectableObservableAssembly(Function<? super ConnectableObservable, ? extends ConnectableObservable>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setOnFlowableAssembly(Function<? super Flowable, ? extends Flowable>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setOnFlowableSubscribe(BiFunction<? super Flowable, ? super Subscriber, ? extends Subscriber>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setOnMaybeAssembly(Function<? super Maybe, ? extends Maybe>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setOnMaybeSubscribe(BiFunction<? super Maybe, MaybeObserver, ? extends MaybeObserver>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setOnObservableAssembly(Function<? super Observable, ? extends Observable>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setOnObservableSubscribe(BiFunction<? super Observable, ? super Observer, ? extends Observer>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setOnParallelAssembly(Function<? super ParallelFlowable, ? extends ParallelFlowable>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setOnParallelSubscribe(BiFunction<? super ParallelFlowable, ? super Subscriber[], ? extends Subscriber[]>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setOnSingleAssembly(Function<? super Single, ? extends Single>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setOnSingleSubscribe(BiFunction<? super Single, ? super SingleObserver, ? extends SingleObserver>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setScheduleHandler(Function<? super Runnable, ? extends Runnable>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
setSingleSchedulerHandler(Function<? super Scheduler, ? extends Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins
+
+
Sets the specific hook function.
+
+
share() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a new Flowable that multicasts (and shares a single subscription to) the current Flowable.
+
+
share() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a new Observable that multicasts (and shares a single subscription to) the current Observable.
+
+
shutdown() - Method in class io.reactivex.rxjava3.core.Scheduler
+
+
Instructs the Scheduler instance to stop threads, + stop accepting tasks on any outstanding Scheduler.Worker instances + and clean up any associated resources with this Scheduler.
+
+
shutdown() - Static method in class io.reactivex.rxjava3.schedulers.Schedulers
+
+
Shuts down the standard Schedulers.
+
+
SimplePlainQueue<T> - Interface in io.reactivex.rxjava3.operators
+
+
Override of the SimpleQueue interface with no throws Throwable on poll().
+
+
SimpleQueue<T> - Interface in io.reactivex.rxjava3.operators
+
+
A simplified interface for offering, polling and clearing a queue.
+
+
SINGLE - Static variable in annotation type io.reactivex.rxjava3.annotations.SchedulerSupport
+
+
The operator/class runs on RxJava's single scheduler + or takes timing information from it.
+
+
single(T) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits the single item emitted by the current Flowable if it + emits only a single item, or a default item if the current Flowable emits no items.
+
+
single(T) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits the single item emitted by the current Observable, if the current Observable + emits only a single item, or a default item if the current Observable emits no items.
+
+
Single<T> - Class in io.reactivex.rxjava3.core
+
+
The Single class implements the Reactive Pattern for a single value response.
+
+
Single() - Constructor for class io.reactivex.rxjava3.core.Single
+
 
+
single() - Static method in class io.reactivex.rxjava3.schedulers.Schedulers
+
+
Returns a default, shared, single-thread-backed Scheduler instance for work + requiring strongly-sequential execution on the same background thread.
+
+
SingleConverter<T,R> - Interface in io.reactivex.rxjava3.core
+
+
Convenience interface and callback used by the Single.to(io.reactivex.rxjava3.core.SingleConverter<T, ? extends R>) operator to turn a Single into another + value fluently.
+
+
singleElement() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Maybe that completes if this Flowable is empty, signals one item if this Flowable + signals exactly one item or signals an IllegalArgumentException if this Flowable signals + more than one item.
+
+
singleElement() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Maybe that completes if the current Observable is empty or emits the single item + emitted by the current Observable, or signals an IllegalArgumentException if the current + Observable emits more than one item.
+
+
SingleEmitter<T> - Interface in io.reactivex.rxjava3.core
+
+
Abstraction over an RxJava SingleObserver that allows associating + a resource with it.
+
+
SingleObserver<T> - Interface in io.reactivex.rxjava3.core
+
+
Provides a mechanism for receiving push-based notification of a single value or an error.
+
+
SingleOnSubscribe<T> - Interface in io.reactivex.rxjava3.core
+
+
A functional interface that has a subscribe() method that receives + a SingleEmitter instance that allows pushing + an event in a cancellation-safe manner.
+
+
SingleOperator<Downstream,Upstream> - Interface in io.reactivex.rxjava3.core
+
+
Interface to map/wrap a downstream SingleObserver to an upstream SingleObserver.
+
+
singleOrError() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits the single item emitted by this Flowable, if this Flowable + emits only a single item, otherwise + if this Flowable completes without emitting any items a NoSuchElementException will be signaled and + if this Flowable emits more than one item, an IllegalArgumentException will be signaled.
+
+
singleOrError() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits the single item emitted by the current Observable if it + emits only a single item, otherwise + if the current Observable completes without emitting any items or emits more than one item a + NoSuchElementException or IllegalArgumentException will be signaled respectively.
+
+
singleOrErrorStage() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Signals the only expected upstream item, a NoSuchElementException if the upstream is empty + or signals IllegalArgumentException if the upstream has more than one item + via a CompletionStage.
+
+
singleOrErrorStage() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Signals the only expected upstream item, a NoSuchElementException if the upstream is empty + or signals IllegalArgumentException if the upstream has more than one item + via a CompletionStage.
+
+
SingleSource<T> - Interface in io.reactivex.rxjava3.core
+
+
Represents a basic Single source base interface, + consumable via an SingleObserver.
+
+
singleStage(T) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Signals the only expected upstream item (or the default item if the upstream is empty) + or signals IllegalArgumentException if the upstream has more than one item + via a CompletionStage.
+
+
singleStage(T) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Signals the only expected upstream item (or the default item if the upstream is empty) + or signals IllegalArgumentException if the upstream has more than one item + via a CompletionStage.
+
+
SingleSubject<T> - Class in io.reactivex.rxjava3.subjects
+
+
Represents a hot Single-like source and consumer of events similar to Subjects.
+
+
SingleTransformer<Upstream,Downstream> - Interface in io.reactivex.rxjava3.core
+
+
Interface to compose Singles.
+
+
size() - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable
+
+
Returns the number of currently held Disposables.
+
+
size() - Method in exception io.reactivex.rxjava3.exceptions.CompositeException
+
+
Returns the number of suppressed exceptions.
+
+
size() - Method in class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue
+
+
Returns the number of elements in the queue.
+
+
skip(long) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that skips the first count items emitted by the current Flowable and emits + the remainder.
+
+
skip(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that skips values emitted by the current Flowable before a specified time window + elapses.
+
+
skip(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that skips values emitted by the current Flowable before a specified time window + on a specified Scheduler elapses.
+
+
skip(long) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that skips the first count items emitted by the current Observable and emits + the remainder.
+
+
skip(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that skips values emitted by the current Observable before a specified time window + elapses.
+
+
skip(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that skips values emitted by the current Observable before a specified time window + on a specified Scheduler elapses.
+
+
skipLast(int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that drops a specified number of items from the end of the sequence emitted by the + current Flowable.
+
+
skipLast(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that drops items emitted by the current Flowable during a specified time window + before the source completes.
+
+
skipLast(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that drops items emitted by the current Flowable during a specified time window + before the source completes.
+
+
skipLast(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that drops items emitted by the current Flowable during a specified time window + (defined on a specified scheduler) before the source completes.
+
+
skipLast(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that drops items emitted by the current Flowable during a specified time window + (defined on a specified scheduler) before the source completes.
+
+
skipLast(long, TimeUnit, Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that drops items emitted by the current Flowable during a specified time window + (defined on a specified scheduler) before the source completes.
+
+
skipLast(int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that drops a specified number of items from the end of the sequence emitted by the + current Observable.
+
+
skipLast(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that drops items emitted by the current Observable during a specified time window + before the source completes.
+
+
skipLast(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that drops items emitted by the current Observable during a specified time window + before the source completes.
+
+
skipLast(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that drops items emitted by the current Observable during a specified time window + (defined on a specified scheduler) before the source completes.
+
+
skipLast(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that drops items emitted by the current Observable during a specified time window + (defined on a specified scheduler) before the source completes.
+
+
skipLast(long, TimeUnit, Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that drops items emitted by the current Observable during a specified time window + (defined on a specified scheduler) before the source completes.
+
+
skipUntil(Publisher<U>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that skips items emitted by the current Flowable until a second Publisher emits + an item.
+
+
skipUntil(ObservableSource<U>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that skips items emitted by the current Observable until a second ObservableSource emits + an item.
+
+
skipWhile(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that skips all items emitted by the current Flowable as long as a specified + condition holds true, but emits all further source items as soon as the condition becomes false.
+
+
skipWhile(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that skips all items emitted by the current Observable as long as a specified + condition holds true, but emits all further source items as soon as the condition becomes false.
+
+
sorted() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the events emitted by source Publisher, in a + sorted order.
+
+
sorted(Comparator<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the events emitted by source Publisher, in a + sorted order based on a specified comparison function.
+
+
sorted() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the events emitted by the current Observable, in a + sorted order.
+
+
sorted(Comparator<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the events emitted by the current Observable, in a + sorted order based on a specified comparison function.
+
+
sorted(Comparator<? super T>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Sorts the 'rails' of this ParallelFlowable and returns a Flowable that sequentially + picks the smallest next value from the rails.
+
+
sorted(Comparator<? super T>, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Sorts the 'rails' of this ParallelFlowable and returns a Flowable that sequentially + picks the smallest next value from the rails.
+
+
SpscArrayQueue<E> - Class in io.reactivex.rxjava3.operators
+
+
A Single-Producer-Single-Consumer queue backed by a pre-allocated buffer.
+
+
SpscArrayQueue(int) - Constructor for class io.reactivex.rxjava3.operators.SpscArrayQueue
+
+
Constructs an array-backed queue with the given capacity rounded + up to the next power of 2 size.
+
+
SpscLinkedArrayQueue<T> - Class in io.reactivex.rxjava3.operators
+
+
A single-producer single-consumer array-backed queue which can allocate new arrays in case the consumer is slower + than the producer.
+
+
SpscLinkedArrayQueue(int) - Constructor for class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue
+
+
Constructs a linked array-based queue instance with the given + island size rounded up to the next power of 2.
+
+
start() - Method in class io.reactivex.rxjava3.core.Scheduler
+
+
Allows the Scheduler instance to start threads + and accept tasks on them.
+
+
start() - Method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
+
Initializes this Processor by setting an upstream Subscription that + ignores request amounts, uses a fixed buffer + and allows using the onXXX and offer methods + afterwards.
+
+
start() - Static method in class io.reactivex.rxjava3.schedulers.Schedulers
+
+
Starts the standard Schedulers.
+
+
startUnbounded() - Method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
+
Initializes this Processor by setting an upstream Subscription that + ignores request amounts, uses an unbounded buffer + and allows using the onXXX and offer methods + afterwards.
+
+
startWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which first runs the other CompletableSource + then the current Completable if the other completed normally.
+
+
startWith(SingleSource<T>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Flowable which first runs the other SingleSource + then the current Completable if the other succeeded normally.
+
+
startWith(MaybeSource<T>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Flowable which first runs the other MaybeSource + then the current Completable if the other succeeded or completed normally.
+
+
startWith(ObservableSource<T>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns an Observable which first delivers the events + of the other ObservableSource then runs the current Completable.
+
+
startWith(Publisher<T>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Flowable which first delivers the events + of the other Publisher then runs the current Completable.
+
+
startWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable which first runs the other CompletableSource + then the current Flowable if the other completed normally.
+
+
startWith(SingleSource<T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable which first runs the other SingleSource + then the current Flowable if the other succeeded normally.
+
+
startWith(MaybeSource<T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable which first runs the other MaybeSource + then the current Flowable if the other succeeded or completed normally.
+
+
startWith(Publisher<? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items in a specified Publisher before it begins to emit + items emitted by the current Flowable.
+
+
startWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Flowable which first runs the other CompletableSource + then the current Maybe if the other completed normally.
+
+
startWith(SingleSource<T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Flowable which first runs the other SingleSource + then the current Maybe if the other succeeded normally.
+
+
startWith(MaybeSource<T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Flowable which first runs the other MaybeSource + then the current Maybe if the other succeeded or completed normally.
+
+
startWith(ObservableSource<T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns an Observable which first delivers the events + of the other ObservableSource then runs the current Maybe.
+
+
startWith(Publisher<T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Flowable which first delivers the events + of the other Publisher then runs the current Maybe.
+
+
startWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable which first runs the other CompletableSource + then the current Observable if the other completed normally.
+
+
startWith(SingleSource<T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable which first runs the other SingleSource + then the current Observable if the other succeeded normally.
+
+
startWith(MaybeSource<T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable which first runs the other MaybeSource + then the current Observable if the other succeeded or completed normally.
+
+
startWith(ObservableSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items in a specified ObservableSource before it begins to emit + items emitted by the current Observable.
+
+
startWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Flowable which first runs the other CompletableSource + then the current Single if the other completed normally.
+
+
startWith(SingleSource<T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Flowable which first runs the other SingleSource + then the current Single if the other succeeded normally.
+
+
startWith(MaybeSource<T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Flowable which first runs the other MaybeSource + then the current Single if the other succeeded or completed normally.
+
+
startWith(ObservableSource<T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns an Observable which first delivers the events + of the other ObservableSource then runs the current Single.
+
+
startWith(Publisher<T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Flowable which first delivers the events + of the other Publisher then runs the current Single.
+
+
startWithArray(T...) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the specified items before it begins to emit items emitted by the current + Flowable.
+
+
startWithArray(T...) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the specified items before it begins to emit items emitted by the current + Observable.
+
+
startWithItem(T) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits a specified item before it begins to emit items emitted by the current + Flowable.
+
+
startWithItem(T) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits a specified item before it begins to emit items emitted by the current + Observable.
+
+
startWithIterable(Iterable<? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items in a specified Iterable before it begins to emit items + emitted by the current Flowable.
+
+
startWithIterable(Iterable<? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items in a specified Iterable before it begins to emit items + emitted by the current Observable.
+
+
Subject<T> - Class in io.reactivex.rxjava3.subjects
+
+
Represents an Observer and an Observable at the same time, allowing + multicasting events from a single source to multiple child Observers.
+
+
Subject() - Constructor for class io.reactivex.rxjava3.subjects.Subject
+
 
+
subscribe() - Method in class io.reactivex.rxjava3.core.Completable
+
+
Subscribes to this Completable and returns a Disposable which can be used to dispose + the subscription.
+
+
subscribe(CompletableObserver) - Method in class io.reactivex.rxjava3.core.Completable
+
 
+
subscribe(Action, Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Subscribes to this Completable and calls back either the onError or onComplete functions.
+
+
subscribe(Action, Consumer<? super Throwable>, DisposableContainer) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Wraps the given onXXX callbacks into a Disposable CompletableObserver, + adds it to the given DisposableContainer and ensures, that if the upstream + terminates or this particular Disposable is disposed, the CompletableObserver is removed + from the given composite.
+
+
subscribe(Action) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Subscribes to this Completable and calls the given Action when this Completable + completes normally.
+
+
subscribe(CompletableEmitter) - Method in interface io.reactivex.rxjava3.core.CompletableOnSubscribe
+
+
Called for each CompletableObserver that subscribes.
+
+
subscribe(CompletableObserver) - Method in interface io.reactivex.rxjava3.core.CompletableSource
+
+
Subscribes the given CompletableObserver to this CompletableSource instance.
+
+
subscribe() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the current Flowable and ignores onNext and onComplete emissions.
+
+
subscribe(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the current Flowable and provides a callback to handle the items it emits.
+
+
subscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the current Flowable and provides callbacks to handle the items it emits and any error + notification it issues.
+
+
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Action) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes to the current Flowable and provides callbacks to handle the items it emits and any error or + completion notification it issues.
+
+
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Action, DisposableContainer) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Wraps the given onXXX callbacks into a Disposable Subscriber, + adds it to the given DisposableContainer and ensures, that if the upstream + terminates or this particular Disposable is disposed, the Subscriber is removed + from the given container.
+
+
subscribe(Subscriber<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
 
+
subscribe(FlowableSubscriber<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Establish a connection between this Flowable and the given FlowableSubscriber and + start streaming events based on the demand of the FlowableSubscriber.
+
+
subscribe(FlowableEmitter<T>) - Method in interface io.reactivex.rxjava3.core.FlowableOnSubscribe
+
+
Called for each Subscriber that subscribes.
+
+
subscribe() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Subscribes to a Maybe and ignores onSuccess and onComplete emissions.
+
+
subscribe(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Subscribes to a Maybe and provides a callback to handle the items it emits.
+
+
subscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Subscribes to a Maybe and provides callbacks to handle the items it emits and any error + notification it issues.
+
+
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Action) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Subscribes to a Maybe and provides callbacks to handle the items it emits and any error or + completion notification it issues.
+
+
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Action, DisposableContainer) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Wraps the given onXXX callbacks into a Disposable MaybeObserver, + adds it to the given DisposableContainer and ensures, that if the upstream + terminates or this particular Disposable is disposed, the MaybeObserver is removed + from the given composite.
+
+
subscribe(MaybeObserver<? super T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
 
+
subscribe(MaybeEmitter<T>) - Method in interface io.reactivex.rxjava3.core.MaybeOnSubscribe
+
+
Called for each MaybeObserver that subscribes.
+
+
subscribe(MaybeObserver<? super T>) - Method in interface io.reactivex.rxjava3.core.MaybeSource
+
+
Subscribes the given MaybeObserver to this MaybeSource instance.
+
+
subscribe() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Subscribes to the current Observable and ignores onNext and onComplete emissions.
+
+
subscribe(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Subscribes to the current Observable and provides a callback to handle the items it emits.
+
+
subscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Subscribes to the current Observable and provides callbacks to handle the items it emits and any error + notification it signals.
+
+
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Action) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Subscribes to the current Observable and provides callbacks to handle the items it emits and any error or + completion notification it signals.
+
+
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Action, DisposableContainer) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Wraps the given onXXX callbacks into a Disposable Observer, + adds it to the given DisposableContainer and ensures, that if the upstream + terminates or this particular Disposable is disposed, the Observer is removed + from the given container.
+
+
subscribe(Observer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
 
+
subscribe(ObservableEmitter<T>) - Method in interface io.reactivex.rxjava3.core.ObservableOnSubscribe
+
+
Called for each Observer that subscribes.
+
+
subscribe(Observer<? super T>) - Method in interface io.reactivex.rxjava3.core.ObservableSource
+
+
Subscribes the given Observer to this ObservableSource instance.
+
+
subscribe() - Method in class io.reactivex.rxjava3.core.Single
+
+
Subscribes to a Single but ignore its emission or notification.
+
+
subscribe(BiConsumer<? super T, ? super Throwable>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Subscribes to a Single and provides a composite callback to handle the item it emits + or any error notification it issues.
+
+
subscribe(Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Subscribes to a Single and provides a callback to handle the item it emits.
+
+
subscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Subscribes to a Single and provides callbacks to handle the item it emits or any error notification it + issues.
+
+
subscribe(Consumer<? super T>, Consumer<? super Throwable>, DisposableContainer) - Method in class io.reactivex.rxjava3.core.Single
+
+
Wraps the given onXXX callbacks into a Disposable SingleObserver, + adds it to the given DisposableContainer and ensures, that if the upstream + terminates or this particular Disposable is disposed, the SingleObserver is removed + from the given container.
+
+
subscribe(SingleObserver<? super T>) - Method in class io.reactivex.rxjava3.core.Single
+
 
+
subscribe(SingleEmitter<T>) - Method in interface io.reactivex.rxjava3.core.SingleOnSubscribe
+
+
Called for each SingleObserver that subscribes.
+
+
subscribe(SingleObserver<? super T>) - Method in interface io.reactivex.rxjava3.core.SingleSource
+
+
Subscribes the given SingleObserver to this SingleSource instance.
+
+
subscribe(Subscriber<? super T>[]) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Subscribes an array of Subscribers to this ParallelFlowable and triggers + the execution chain for all 'rails'.
+
+
subscribeActual(CompletableObserver) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Implement this method to handle the incoming CompletableObservers and + perform the business logic in your operator.
+
+
subscribeActual(Subscriber<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Operator implementations (both source and intermediate) should implement this method that + performs the necessary business logic and handles the incoming Subscribers.
+
+
subscribeActual(MaybeObserver<? super T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Implement this method in subclasses to handle the incoming MaybeObservers.
+
+
subscribeActual(Observer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Operator implementations (both source and intermediate) should implement this method that + performs the necessary business logic and handles the incoming Observers.
+
+
subscribeActual(SingleObserver<? super T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Implement this method in subclasses to handle the incoming SingleObservers.
+
+
subscribeActual(Subscriber<? super T>) - Method in class io.reactivex.rxjava3.processors.AsyncProcessor
+
 
+
subscribeActual(Subscriber<? super T>) - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor
+
 
+
subscribeActual(Subscriber<? super T>) - Method in class io.reactivex.rxjava3.processors.MulticastProcessor
+
 
+
subscribeActual(Subscriber<? super T>) - Method in class io.reactivex.rxjava3.processors.PublishProcessor
+
 
+
subscribeActual(Subscriber<? super T>) - Method in class io.reactivex.rxjava3.processors.ReplayProcessor
+
 
+
subscribeActual(Subscriber<? super T>) - Method in class io.reactivex.rxjava3.processors.UnicastProcessor
+
 
+
subscribeActual(Observer<? super T>) - Method in class io.reactivex.rxjava3.subjects.AsyncSubject
+
 
+
subscribeActual(Observer<? super T>) - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject
+
 
+
subscribeActual(CompletableObserver) - Method in class io.reactivex.rxjava3.subjects.CompletableSubject
+
 
+
subscribeActual(MaybeObserver<? super T>) - Method in class io.reactivex.rxjava3.subjects.MaybeSubject
+
 
+
subscribeActual(Observer<? super T>) - Method in class io.reactivex.rxjava3.subjects.PublishSubject
+
 
+
subscribeActual(Observer<? super T>) - Method in class io.reactivex.rxjava3.subjects.ReplaySubject
+
 
+
subscribeActual(SingleObserver<? super T>) - Method in class io.reactivex.rxjava3.subjects.SingleSubject
+
 
+
subscribeActual(Observer<? super T>) - Method in class io.reactivex.rxjava3.subjects.UnicastSubject
+
 
+
subscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which subscribes the downstream subscriber on the specified scheduler, making + sure the subscription side-effects happen on that specific thread of the Scheduler.
+
+
subscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Asynchronously subscribes Subscribers to the current Flowable on the specified Scheduler.
+
+
subscribeOn(Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Asynchronously subscribes Subscribers to the current Flowable on the specified Scheduler + optionally reroutes requests from other threads to the same Scheduler thread.
+
+
subscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Asynchronously subscribes subscribers to this Maybe on the specified Scheduler.
+
+
subscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Asynchronously subscribes Observers to the current Observable on the specified Scheduler.
+
+
subscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Single
+
+
Asynchronously subscribes SingleObservers to this Single on the specified Scheduler.
+
+
subscribeWith(E) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Subscribes a given CompletableObserver (subclass) to this Completable and returns the given + CompletableObserver as is.
+
+
subscribeWith(E) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Subscribes a given Subscriber (subclass) to this Flowable and returns the given + Subscriber as is.
+
+
subscribeWith(E) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Subscribes a given MaybeObserver (subclass) to this Maybe and returns the given + MaybeObserver as is.
+
+
subscribeWith(E) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Subscribes a given Observer (subclass) to the current Observable and returns the given + Observer instance as is.
+
+
subscribeWith(E) - Method in class io.reactivex.rxjava3.core.Single
+
+
Subscribes a given SingleObserver (subclass) to this Single and returns the given + SingleObserver as is.
+
+
Supplier<T> - Interface in io.reactivex.rxjava3.functions
+
+
A functional interface (callback) that provides a single value or + throws an exception.
+
+
switchIfEmpty(Publisher<? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items emitted by the current Flowable or the items of an alternate + Publisher if the current Flowable is empty.
+
+
switchIfEmpty(MaybeSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits the items emitted by the current Maybe or the items of an alternate + MaybeSource if the current Maybe is empty.
+
+
switchIfEmpty(SingleSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Single that emits the items emitted by the current Maybe or the item of an alternate + SingleSource if the current Maybe is empty.
+
+
switchIfEmpty(ObservableSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items emitted by the current Observable or the items of an alternate + ObservableSource if the current Observable is empty.
+
+
switchMap(Function<? super T, ? extends Publisher<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a new Flowable by applying a function that you supply to each item emitted by the current + Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted + of these Publishers.
+
+
switchMap(Function<? super T, ? extends Publisher<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a new Flowable by applying a function that you supply to each item emitted by the current + Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted + of these Publishers.
+
+
switchMap(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a new Observable by applying a function that you supply to each item emitted by the current + Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted + of these ObservableSources.
+
+
switchMap(Function<? super T, ? extends ObservableSource<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a new Observable by applying a function that you supply to each item emitted by the current + Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted + of these ObservableSources.
+
+
switchMapCompletable(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream values into CompletableSources, subscribes to the newer one while + disposing the subscription to the previous CompletableSource, thus keeping at most one + active CompletableSource running.
+
+
switchMapCompletable(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the items of the current Observable into CompletableSources, subscribes to the newer one while + disposing the subscription to the previous CompletableSource, thus keeping at most one + active CompletableSource running.
+
+
switchMapCompletableDelayError(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream values into CompletableSources, subscribes to the newer one while + disposing the subscription to the previous CompletableSource, thus keeping at most one + active CompletableSource running and delaying any main or inner errors until all + of them terminate.
+
+
switchMapCompletableDelayError(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the upstream values into CompletableSources, subscribes to the newer one while + disposing the subscription to the previous CompletableSource, thus keeping at most one + active CompletableSource running and delaying any main or inner errors until all + of them terminate.
+
+
switchMapDelayError(Function<? super T, ? extends Publisher<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a new Flowable by applying a function that you supply to each item emitted by the current + Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted + of these Publishers and delays any error until all Publishers terminate.
+
+
switchMapDelayError(Function<? super T, ? extends Publisher<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a new Flowable by applying a function that you supply to each item emitted by the current + Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted + of these Publishers and delays any error until all Publishers terminate.
+
+
switchMapDelayError(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a new Observable by applying a function that you supply to each item emitted by the current + Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted + of these ObservableSources and delays any error until all ObservableSources terminate.
+
+
switchMapDelayError(Function<? super T, ? extends ObservableSource<? extends R>>, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a new Observable by applying a function that you supply to each item emitted by the current + Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted + of these ObservableSources and delays any error until all ObservableSources terminate.
+
+
switchMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones + while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if + available while failing immediately if this Flowable or any of the + active inner MaybeSources fail.
+
+
switchMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the items of the current Observable into MaybeSources and switches (subscribes) to the newer ones + while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if + available while failing immediately if the current Observable or any of the + active inner MaybeSources fail.
+
+
switchMapMaybeDelayError(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones + while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if + available, delaying errors from this Flowable or the inner MaybeSources until all terminate.
+
+
switchMapMaybeDelayError(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones + while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if + available, delaying errors from the current Observable or the inner MaybeSources until all terminate.
+
+
switchMapSingle(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into SingleSources and switches (subscribes) to the newer ones + while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one + while failing immediately if this Flowable or any of the + active inner SingleSources fail.
+
+
switchMapSingle(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a new Observable by applying a function that you supply to each item emitted by the current + Observable that returns a SingleSource, and then emitting the item emitted by the most recently emitted + of these SingleSources.
+
+
switchMapSingleDelayError(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Maps the upstream items into SingleSources and switches (subscribes) to the newer ones + while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one, + delaying errors from this Flowable or the inner SingleSources until all terminate.
+
+
switchMapSingleDelayError(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a new Observable by applying a function that you supply to each item emitted by the current + Observable that returns a SingleSource, and then emitting the item emitted by the most recently emitted + of these SingleSources and delays any error until all SingleSources terminate.
+
+
switchOnNext(Publisher<? extends CompletableSource>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Switches between CompletableSources emitted by the source Publisher whenever + a new CompletableSource is emitted, disposing the previously running CompletableSource, + exposing the setup as a Completable sequence.
+
+
switchOnNext(Publisher<? extends Publisher<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the + most recently emitted of those Publishers.
+
+
switchOnNext(Publisher<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the + most recently emitted of those Publishers.
+
+
switchOnNext(Publisher<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Switches between MaybeSources emitted by the source Publisher whenever + a new MaybeSource is emitted, disposing the previously running MaybeSource, + exposing the success items as a Flowable sequence.
+
+
switchOnNext(ObservableSource<? extends ObservableSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the + most recently emitted of those ObservableSources.
+
+
switchOnNext(ObservableSource<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the + most recently emitted of those ObservableSources.
+
+
switchOnNext(Publisher<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Switches between SingleSources emitted by the source Publisher whenever + a new SingleSource is emitted, disposing the previously running SingleSource, + exposing the success items as a Flowable sequence.
+
+
switchOnNextDelayError(Publisher<? extends CompletableSource>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Switches between CompletableSources emitted by the source Publisher whenever + a new CompletableSource is emitted, disposing the previously running CompletableSource, + exposing the setup as a Completable sequence and delaying all errors from + all of them until all terminate.
+
+
switchOnNextDelayError(Publisher<? extends Publisher<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the + most recently emitted of those Publishers and delays any exception until all Publishers terminate.
+
+
switchOnNextDelayError(Publisher<? extends Publisher<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the + most recently emitted of those Publishers and delays any exception until all Publishers terminate.
+
+
switchOnNextDelayError(Publisher<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Switches between MaybeSources emitted by the source Publisher whenever + a new MaybeSource is emitted, disposing the previously running MaybeSource, + exposing the success items as a Flowable sequence and delaying all errors from + all of them until all terminate.
+
+
switchOnNextDelayError(ObservableSource<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the + most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
+
+
switchOnNextDelayError(ObservableSource<? extends ObservableSource<? extends T>>, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the + most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
+
+
switchOnNextDelayError(Publisher<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Switches between SingleSources emitted by the source Publisher whenever + a new SingleSource is emitted, disposing the previously running SingleSource, + exposing the success items as a Flowable sequence and delaying all errors from + all of them until all terminate.
+
+
SYNC - Static variable in interface io.reactivex.rxjava3.operators.QueueFuseable
+
+
Request a synchronous fusion mode and can be returned by QueueFuseable.requestFusion(int) + for an accepted mode.
+
+
+ + + +

T

+
+
tag - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
The optional tag associated with this test consumer.
+
+
take(long) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits only the first count items emitted by the current Flowable.
+
+
take(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits those items emitted by source Publisher before a specified time runs + out.
+
+
take(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits those items emitted by source Publisher before a specified time (on a + specified Scheduler) runs out.
+
+
take(long) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits only the first count items emitted by the current Observable.
+
+
take(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits those items emitted by the current Observable before a specified time runs + out.
+
+
take(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits those items emitted by the current Observable before a specified time (on a + specified Scheduler) runs out.
+
+
takeLast(int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits at most the last count items emitted by the current Flowable.
+
+
takeLast(long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits at most a specified number of items from the current Flowable that were + emitted in a specified window of time before the current Flowable completed.
+
+
takeLast(long, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits at most a specified number of items from the current Flowable that were + emitted in a specified window of time before the current Flowable completed, where the timing information is + provided by a given Scheduler.
+
+
takeLast(long, long, TimeUnit, Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits at most a specified number of items from the current Flowable that were + emitted in a specified window of time before the current Flowable completed, where the timing information is + provided by a given Scheduler.
+
+
takeLast(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items from the current Flowable that were emitted in a specified + window of time before the current Flowable completed.
+
+
takeLast(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items from the current Flowable that were emitted in a specified + window of time before the current Flowable completed.
+
+
takeLast(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items from the current Flowable that were emitted in a specified + window of time before the current Flowable completed, where the timing information is provided by a specified + Scheduler.
+
+
takeLast(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items from the current Flowable that were emitted in a specified + window of time before the current Flowable completed, where the timing information is provided by a specified + Scheduler.
+
+
takeLast(long, TimeUnit, Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items from the current Flowable that were emitted in a specified + window of time before the current Flowable completed, where the timing information is provided by a specified + Scheduler.
+
+
takeLast(int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits at most the last count items emitted by the current Observable.
+
+
takeLast(long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits at most a specified number of items from the current Observable that were + emitted in a specified window of time before the current Observable completed.
+
+
takeLast(long, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits at most a specified number of items from the current Observable that were + emitted in a specified window of time before the current Observable completed, where the timing information is + provided by a given Scheduler.
+
+
takeLast(long, long, TimeUnit, Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits at most a specified number of items from the current Observable that were + emitted in a specified window of time before the current Observable completed, where the timing information is + provided by a given Scheduler.
+
+
takeLast(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items from the current Observable that were emitted in a specified + window of time before the current Observable completed.
+
+
takeLast(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items from the current Observable that were emitted in a specified + window of time before the current Observable completed.
+
+
takeLast(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items from the current Observable that were emitted in a specified + window of time before the current Observable completed, where the timing information is provided by a specified + Scheduler.
+
+
takeLast(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items from the current Observable that were emitted in a specified + window of time before the current Observable completed, where the timing information is provided by a specified + Scheduler.
+
+
takeLast(long, TimeUnit, Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items from the current Observable that were emitted in a specified + window of time before the current Observable completed, where the timing information is provided by a specified + Scheduler.
+
+
takeUntil(CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Terminates the downstream if this or the other Completable + terminates (wins the termination race) while disposing the connection to the losing source.
+
+
takeUntil(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items emitted by the current Flowable, checks the specified predicate + for each item, and then completes when the condition is satisfied.
+
+
takeUntil(Publisher<U>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the items emitted by the current Flowable until a second Publisher + emits an item or completes.
+
+
takeUntil(MaybeSource<U>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits the items emitted by the current Maybe until a second MaybeSource + emits an item.
+
+
takeUntil(Publisher<U>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits the item emitted by the current Maybe until a second Publisher + emits an item.
+
+
takeUntil(ObservableSource<U>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the items emitted by the current Observable until a second ObservableSource + emits an item or completes.
+
+
takeUntil(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items emitted by the current Observable, checks the specified predicate + for each item, and then completes when the condition is satisfied.
+
+
takeUntil(CompletableSource) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that emits the item emitted by the current Single until a CompletableSource terminates.
+
+
takeUntil(Publisher<E>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that emits the item emitted by the current Single until a Publisher emits an item or completes.
+
+
takeUntil(SingleSource<? extends E>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that emits the item emitted by the current Single until a second Single emits an item.
+
+
takeWhile(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items emitted by the current Flowable so long as each item satisfied a + specified condition, and then completes as soon as this condition is not satisfied.
+
+
takeWhile(Predicate<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items emitted by the current Observable so long as each item satisfied a + specified condition, and then completes as soon as this condition is not satisfied.
+
+
test() - Method in class io.reactivex.rxjava3.core.Completable
+
+
Creates a TestObserver and subscribes + it to this Completable.
+
+
test(boolean) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Creates a TestObserver optionally in cancelled state, then subscribes it to this Completable.
+
+
test() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Creates a TestSubscriber that requests Long.MAX_VALUE and subscribes + it to this Flowable.
+
+
test(long) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Creates a TestSubscriber with the given initial request amount and subscribes + it to this Flowable.
+
+
test(long, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Creates a TestSubscriber with the given initial request amount, + optionally cancels it before the subscription and subscribes + it to this Flowable.
+
+
test() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Creates a TestObserver and subscribes + it to this Maybe.
+
+
test(boolean) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Creates a TestObserver optionally in cancelled state, then subscribes it to this Maybe.
+
+
test() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Creates a TestObserver and subscribes it to the current Observable.
+
+
test(boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Creates a TestObserver, optionally disposes it and then subscribes + it to the current Observable.
+
+
test() - Method in class io.reactivex.rxjava3.core.Single
+
+
Creates a TestObserver and subscribes it to this Single.
+
+
test(boolean) - Method in class io.reactivex.rxjava3.core.Single
+
+
Creates a TestObserver optionally in cancelled state, then subscribes it to this Single.
+
+
test(T1, T2) - Method in interface io.reactivex.rxjava3.functions.BiPredicate
+
+
Test the given input values and return a boolean.
+
+
test(T) - Method in interface io.reactivex.rxjava3.functions.Predicate
+
+
Test the given input value and return a boolean.
+
+
TestObserver<T> - Class in io.reactivex.rxjava3.observers
+
+
An Observer, MaybeObserver, SingleObserver and + CompletableObserver composite that can record events from + Observables, Maybes, Singles and Completables + and allows making assertions about them.
+
+
TestObserver() - Constructor for class io.reactivex.rxjava3.observers.TestObserver
+
+
Constructs a non-forwarding TestObserver.
+
+
TestObserver(Observer<? super T>) - Constructor for class io.reactivex.rxjava3.observers.TestObserver
+
+
Constructs a forwarding TestObserver.
+
+
TestScheduler - Class in io.reactivex.rxjava3.schedulers
+
+
A special, non thread-safe scheduler for testing operators that require + a scheduler without introducing real concurrency and allows manually advancing + a virtual time.
+
+
TestScheduler() - Constructor for class io.reactivex.rxjava3.schedulers.TestScheduler
+
+
Creates a new TestScheduler with initial virtual time of zero.
+
+
TestScheduler(boolean) - Constructor for class io.reactivex.rxjava3.schedulers.TestScheduler
+
+
Creates a new TestScheduler with the option to use the + RxJavaPlugins.onSchedule(Runnable) hook when scheduling tasks.
+
+
TestScheduler(long, TimeUnit) - Constructor for class io.reactivex.rxjava3.schedulers.TestScheduler
+
+
Creates a new TestScheduler with the specified initial virtual time.
+
+
TestScheduler(long, TimeUnit, boolean) - Constructor for class io.reactivex.rxjava3.schedulers.TestScheduler
+
+
Creates a new TestScheduler with the specified initial virtual time + and with the option to use the + RxJavaPlugins.onSchedule(Runnable) hook when scheduling tasks.
+
+
TestSubscriber<T> - Class in io.reactivex.rxjava3.subscribers
+
+
A Subscriber implementation that records events and allows making assertions about them.
+
+
TestSubscriber() - Constructor for class io.reactivex.rxjava3.subscribers.TestSubscriber
+
+
Constructs a non-forwarding TestSubscriber with an initial request value of Long.MAX_VALUE.
+
+
TestSubscriber(long) - Constructor for class io.reactivex.rxjava3.subscribers.TestSubscriber
+
+
Constructs a non-forwarding TestSubscriber with the specified initial request value.
+
+
TestSubscriber(Subscriber<? super T>) - Constructor for class io.reactivex.rxjava3.subscribers.TestSubscriber
+
+
Constructs a forwarding TestSubscriber but leaves the requesting to the wrapped Subscriber.
+
+
TestSubscriber(Subscriber<? super T>, long) - Constructor for class io.reactivex.rxjava3.subscribers.TestSubscriber
+
+
Constructs a forwarding TestSubscriber with the specified initial request amount + and an actual Subscriber to forward events to.
+
+
throttleFirst(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits only the first item emitted by the current Flowable during sequential + time windows of a specified duration.
+
+
throttleFirst(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits only the first item emitted by the current Flowable during sequential + time windows of a specified duration, where the windows are managed by a specified Scheduler.
+
+
throttleFirst(long, TimeUnit, Scheduler, Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits only the first item emitted by the current Flowable during sequential + time windows of a specified duration, where the windows are managed by a specified Scheduler.
+
+
throttleFirst(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits only the first item emitted by the current Observable during sequential + time windows of a specified duration.
+
+
throttleFirst(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits only the first item emitted by the current Observable during sequential + time windows of a specified duration, where the windows are managed by a specified Scheduler.
+
+
throttleFirst(long, TimeUnit, Scheduler, Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits only the first item emitted by the current Observable during sequential + time windows of a specified duration, where the windows are managed by a specified Scheduler.
+
+
throttleLast(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits only the last item emitted by the current Flowable during sequential + time windows of a specified duration.
+
+
throttleLast(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits only the last item emitted by the current Flowable during sequential + time windows of a specified duration, where the duration is governed by a specified Scheduler.
+
+
throttleLast(long, TimeUnit, Scheduler, Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits only the last item emitted by the current Flowable during sequential + time windows of a specified duration, where the duration is governed by a specified Scheduler.
+
+
throttleLast(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits only the last item emitted by the current Observable during sequential + time windows of a specified duration.
+
+
throttleLast(long, TimeUnit, Scheduler, Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits only the last item emitted by the current Observable during sequential + time windows of a specified duration, where the duration is governed by a specified Scheduler.
+
+
throttleLast(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits only the last item emitted by the current Observable during sequential + time windows of a specified duration, where the duration is governed by a specified Scheduler.
+
+
throttleLatest(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Throttles items from the upstream Flowable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them.
+
+
throttleLatest(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Throttles items from the upstream Flowable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them.
+
+
throttleLatest(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Throttles items from the upstream Flowable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them.
+
+
throttleLatest(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Throttles items from the upstream Flowable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them.
+
+
throttleLatest(long, TimeUnit, Scheduler, boolean, Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Throttles items from the upstream Flowable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them, invoking the consumer for any dropped item.
+
+
throttleLatest(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Throttles items from the current Observable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them.
+
+
throttleLatest(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Throttles items from the current Observable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them.
+
+
throttleLatest(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Throttles items from the current Observable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them.
+
+
throttleLatest(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Throttles items from the current Observable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them.
+
+
throttleLatest(long, TimeUnit, Scheduler, boolean, Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Throttles items from the current Observable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them, invoking the consumer for any dropped item.
+
+
throttleWithTimeout(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the + current Flowable that are followed by newer items before a timeout value expires.
+
+
throttleWithTimeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the + current Flowable that are followed by newer items before a timeout value expires on a specified + Scheduler.
+
+
throttleWithTimeout(long, TimeUnit, Scheduler, Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the + current Flowable that are followed by newer items before a timeout value expires on a specified + Scheduler.
+
+
throttleWithTimeout(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable, except that it drops items emitted by the + current Observable that are followed by newer items before a timeout value expires.
+
+
throttleWithTimeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable, except that it drops items emitted by the + current Observable that are followed by newer items before a timeout value expires on a specified + Scheduler.
+
+
throttleWithTimeout(long, TimeUnit, Scheduler, Consumer<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable, except that it drops items emitted by the + current Observable that are followed by newer items before a timeout value expires on a specified + Scheduler.
+
+
throwIfFatal(Throwable) - Static method in class io.reactivex.rxjava3.exceptions.Exceptions
+
+
Throws a particular Throwable only if it belongs to a set of "fatal" error varieties.
+
+
time() - Method in class io.reactivex.rxjava3.schedulers.Timed
+
+
Returns the time value.
+
+
time(TimeUnit) - Method in class io.reactivex.rxjava3.schedulers.Timed
+
+
Returns the contained time value in the time unit specified.
+
+
Timed<T> - Class in io.reactivex.rxjava3.schedulers
+
+
Holds onto a value along with time information.
+
+
Timed(T, long, TimeUnit) - Constructor for class io.reactivex.rxjava3.schedulers.Timed
+
+
Constructs a Timed instance with the given value and time information.
+
+
timeInterval() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits records of the time interval between consecutive items emitted by the + current Flowable.
+
+
timeInterval(Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits records of the time interval between consecutive items emitted by the + current Flowable, where this interval is computed on a specified Scheduler.
+
+
timeInterval(TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits records of the time interval between consecutive items emitted by the + current Flowable.
+
+
timeInterval(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits records of the time interval between consecutive items emitted by the + current Flowable, where this interval is computed on a specified Scheduler.
+
+
timeInterval() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Measures the time (in milliseconds) between the subscription and success item emission + of the current Maybe and signals it as a tuple (Timed) + success value.
+
+
timeInterval(Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Measures the time (in milliseconds) between the subscription and success item emission + of the current Maybe and signals it as a tuple (Timed) + success value.
+
+
timeInterval(TimeUnit) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Measures the time between the subscription and success item emission + of the current Maybe and signals it as a tuple (Timed) + success value.
+
+
timeInterval(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Measures the time between the subscription and success item emission + of the current Maybe and signals it as a tuple (Timed) + success value.
+
+
timeInterval() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits records of the time interval between consecutive items emitted by the + current Observable.
+
+
timeInterval(Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits records of the time interval between consecutive items emitted by the + current Observable, where this interval is computed on a specified Scheduler.
+
+
timeInterval(TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits records of the time interval between consecutive items emitted by the + current Observable.
+
+
timeInterval(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits records of the time interval between consecutive items emitted by the + current Observable, where this interval is computed on a specified Scheduler.
+
+
timeInterval() - Method in class io.reactivex.rxjava3.core.Single
+
+
Measures the time (in milliseconds) between the subscription and success item emission + of the current Single and signals it as a tuple (Timed) + success value.
+
+
timeInterval(Scheduler) - Method in class io.reactivex.rxjava3.core.Single
+
+
Measures the time (in milliseconds) between the subscription and success item emission + of the current Single and signals it as a tuple (Timed) + success value.
+
+
timeInterval(TimeUnit) - Method in class io.reactivex.rxjava3.core.Single
+
+
Measures the time between the subscription and success item emission + of the current Single and signals it as a tuple (Timed) + success value.
+
+
timeInterval(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Single
+
+
Measures the time between the subscription and success item emission + of the current Single and signals it as a tuple (Timed) + success value.
+
+
timeout(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that runs this Completable and emits a TimeoutException in case + this Completable doesn't complete within the given time.
+
+
timeout(long, TimeUnit, CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that runs this Completable and switches to the other CompletableSource + in case this Completable doesn't complete within the given time.
+
+
timeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that runs this Completable and emits a TimeoutException in case + this Completable doesn't complete within the given time while "waiting" on the specified + Scheduler.
+
+
timeout(long, TimeUnit, Scheduler, CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable that runs this Completable and switches to the other CompletableSource + in case this Completable doesn't complete within the given time while "waiting" on + the specified Scheduler.
+
+
timeout(Function<? super T, ? extends Publisher<V>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable, but notifies Subscribers of a + TimeoutException if an item emitted by the current Flowable doesn't arrive within a window of + time after the emission of the previous item, where that period of time is measured by a Publisher that + is a function of the previous item.
+
+
timeout(Function<? super T, ? extends Publisher<V>>, Publisher<? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable, but that switches to a fallback Publisher if + an item emitted by the current Flowable doesn't arrive within a window of time after the emission of the + previous item, where that period of time is measured by a Publisher that is a function of the previous + item.
+
+
timeout(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted + item.
+
+
timeout(long, TimeUnit, Publisher<? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted + item.
+
+
timeout(long, TimeUnit, Scheduler, Publisher<? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted + item using a specified Scheduler.
+
+
timeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted + item, where this policy is governed by a specified Scheduler.
+
+
timeout(Publisher<U>, Function<? super T, ? extends Publisher<V>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable, but notifies Subscribers of a + TimeoutException if either the first item emitted by the current Flowable or any subsequent item + doesn't arrive within time windows defined by other Publishers.
+
+
timeout(Publisher<U>, Function<? super T, ? extends Publisher<V>>, Publisher<? extends T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that mirrors the current Flowable, but switches to a fallback Publisher if either + the first item emitted by the current Flowable or any subsequent item doesn't arrive within time windows + defined by other Publishers.
+
+
timeout(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted + item.
+
+
timeout(long, TimeUnit, MaybeSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted + item.
+
+
timeout(long, TimeUnit, Scheduler, MaybeSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted + item using a specified Scheduler.
+
+
timeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted + item, where this policy is governed on a specified Scheduler.
+
+
timeout(MaybeSource<U>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
If the current Maybe didn't signal an event before the timeoutIndicator MaybeSource signals, a + TimeoutException is signaled instead.
+
+
timeout(MaybeSource<U>, MaybeSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
If the current Maybe didn't signal an event before the timeoutIndicator MaybeSource signals, + the current Maybe is disposed and the fallback MaybeSource subscribed to + as a continuation.
+
+
timeout(Publisher<U>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
If the current Maybe source didn't signal an event before the timeoutIndicator Publisher signals, a + TimeoutException is signaled instead.
+
+
timeout(Publisher<U>, MaybeSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
If the current Maybe didn't signal an event before the timeoutIndicator Publisher signals, + the current Maybe is disposed and the fallback MaybeSource subscribed to + as a continuation.
+
+
timeout(Function<? super T, ? extends ObservableSource<V>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable, but notifies observers of a + TimeoutException if an item emitted by the current Observable doesn't arrive within a window of + time after the emission of the previous item, where that period of time is measured by an ObservableSource that + is a function of the previous item.
+
+
timeout(Function<? super T, ? extends ObservableSource<V>>, ObservableSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable, but that switches to a fallback ObservableSource if + an item emitted by the current Observable doesn't arrive within a window of time after the emission of the + previous item, where that period of time is measured by an ObservableSource that is a function of the previous + item.
+
+
timeout(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted + item.
+
+
timeout(long, TimeUnit, ObservableSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted + item.
+
+
timeout(long, TimeUnit, Scheduler, ObservableSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted + item using a specified Scheduler.
+
+
timeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted + item, where this policy is governed on a specified Scheduler.
+
+
timeout(ObservableSource<U>, Function<? super T, ? extends ObservableSource<V>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable, but notifies observers of a + TimeoutException if either the first item emitted by the current Observable or any subsequent item + doesn't arrive within time windows defined by indicator ObservableSources.
+
+
timeout(ObservableSource<U>, Function<? super T, ? extends ObservableSource<V>>, ObservableSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that mirrors the current Observable, but switches to a fallback ObservableSource if either + the first item emitted by the current Observable or any subsequent item doesn't arrive within time windows + defined by indicator ObservableSources.
+
+
timeout(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Single
+
+
Signals a TimeoutException if the current Single doesn't signal a success value within the + specified timeout window.
+
+
timeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Single
+
+
Signals a TimeoutException if the current Single doesn't signal a success value within the + specified timeout window.
+
+
timeout(long, TimeUnit, Scheduler, SingleSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Runs the current Single and if it doesn't signal within the specified timeout window, it is + disposed and the other SingleSource subscribed to.
+
+
timeout(long, TimeUnit, SingleSource<? extends T>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Runs the current Single and if it doesn't signal within the specified timeout window, it is + disposed and the other SingleSource subscribed to.
+
+
timeout - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Indicates that one of the awaitX method has timed out.
+
+
timer(long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that fires its onComplete event after the given delay elapsed.
+
+
timer(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance that fires its onComplete event after the given delay elapsed + by using the supplied Scheduler.
+
+
timer(long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits 0L after a specified delay, and then completes.
+
+
timer(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits 0L after a specified delay, on a specified Scheduler, and then + completes.
+
+
timer(long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits 0L after a specified delay.
+
+
timer(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits 0L after a specified delay on a specified Scheduler.
+
+
timer(long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits 0L after a specified delay, and then completes.
+
+
timer(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits 0L after a specified delay, on a specified Scheduler, and then + completes.
+
+
timer(long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Signals success with 0L value after the given delay when a SingleObserver subscribes.
+
+
timer(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Signals success with 0L value on the specified Scheduler after the given + delay when a SingleObserver subscribes.
+
+
timestamp() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a + Timed object.
+
+
timestamp(Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a + Timed object whose timestamps are provided by a specified Scheduler.
+
+
timestamp(TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a + Timed object.
+
+
timestamp(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a + Timed object whose timestamps are provided by a specified Scheduler.
+
+
timestamp() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Combines the success value from the current Maybe with the current time (in milliseconds) of + its reception, using the computation Scheduler as time source, + then signals them as a Timed instance.
+
+
timestamp(Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Combines the success value from the current Maybe with the current time (in milliseconds) of + its reception, using the given Scheduler as time source, + then signals them as a Timed instance.
+
+
timestamp(TimeUnit) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Combines the success value from the current Maybe with the current time of + its reception, using the computation Scheduler as time source, + then signals it as a Timed instance.
+
+
timestamp(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Combines the success value from the current Maybe with the current time of + its reception, using the given Scheduler as time source, + then signals it as a Timed instance.
+
+
timestamp() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits each item emitted by the current Observable, wrapped in a + Timed object.
+
+
timestamp(Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits each item emitted by the current Observable, wrapped in a + Timed object whose timestamps are provided by a specified Scheduler.
+
+
timestamp(TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits each item emitted by the current Observable, wrapped in a + Timed object.
+
+
timestamp(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits each item emitted by the current Observable, wrapped in a + Timed object whose timestamps are provided by a specified Scheduler.
+
+
timestamp() - Method in class io.reactivex.rxjava3.core.Single
+
+
Combines the success value from the current Single with the current time (in milliseconds) of + its reception, using the computation Scheduler as time source, + then signals them as a Timed instance.
+
+
timestamp(Scheduler) - Method in class io.reactivex.rxjava3.core.Single
+
+
Combines the success value from the current Single with the current time (in milliseconds) of + its reception, using the given Scheduler as time source, + then signals them as a Timed instance.
+
+
timestamp(TimeUnit) - Method in class io.reactivex.rxjava3.core.Single
+
+
Combines the success value from the current Single with the current time of + its reception, using the computation Scheduler as time source, + then signals it as a Timed instance.
+
+
timestamp(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Single
+
+
Combines the success value from the current Single with the current time of + its reception, using the given Scheduler as time source, + then signals it as a Timed instance.
+
+
to(CompletableConverter<? extends R>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Calls the specified CompletableConverter function during assembly time and returns its resulting value.
+
+
to(FlowableConverter<T, ? extends R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Calls the specified converter function during assembly time and returns its resulting value.
+
+
to(MaybeConverter<T, ? extends R>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Calls the specified converter function during assembly time and returns its resulting value.
+
+
to(ObservableConverter<T, ? extends R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Calls the specified converter function during assembly time and returns its resulting value.
+
+
to(SingleConverter<T, ? extends R>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Calls the specified converter function during assembly time and returns its resulting value.
+
+
to(ParallelFlowableConverter<T, R>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Calls the specified converter function during assembly time and returns its resulting value.
+
+
toAutoCloseable(Disposable) - Static method in interface io.reactivex.rxjava3.disposables.Disposable
+
+
Construct an AutoCloseable by wrapping a Disposable that is + disposed when the returned AutoCloseable is closed.
+
+
toCompletionStage(T) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Signals the given default item when the upstream completes or signals the upstream error via + a CompletionStage.
+
+
toCompletionStage() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Signals the upstream success item (or a NoSuchElementException if the upstream is empty) via + a CompletionStage.
+
+
toCompletionStage(T) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Signals the upstream success item (or the default item if the upstream is empty) via + a CompletionStage.
+
+
toCompletionStage() - Method in class io.reactivex.rxjava3.core.Single
+
+
Signals the upstream success item (or error) via a CompletionStage.
+
+
toFlowable() - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Flowable which when subscribed to subscribes to this Completable and + relays the terminal events to the downstream Subscriber.
+
+
toFlowable() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Converts this Maybe into a backpressure-aware Flowable instance composing cancellation + through.
+
+
toFlowable(BackpressureStrategy) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Converts the current Observable into a Flowable by applying the specified backpressure strategy.
+
+
toFlowable() - Method in class io.reactivex.rxjava3.core.Single
+
+
Converts this Single into a Flowable.
+
+
toFuture() - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Future representing the termination of the current Completable + via a null value.
+
+
toFuture() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Future representing the only value emitted by this Flowable.
+
+
toFuture() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Future representing the single value emitted by the current Maybe + or null if the current Maybe is empty.
+
+
toFuture() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Future representing the only value emitted by the current Observable.
+
+
toFuture() - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Future representing the single value emitted by this Single.
+
+
toList() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a single item, a list composed of all the items emitted by the + finite upstream source Publisher.
+
+
toList(int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a single item, a list composed of all the items emitted by the + finite source Publisher.
+
+
toList(Supplier<U>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a single item, a list composed of all the items emitted by the + finite source Publisher.
+
+
toList() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a single item, a List composed of all the items emitted by the + current and finite Observable.
+
+
toList(int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a single item, a List composed of all the items emitted by the + current and finite Observable.
+
+
toList(Supplier<U>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a single item, a Collection (subclass) composed of all the items emitted by the + finite upstream Observable.
+
+
toMap(Function<? super T, ? extends K>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a single HashMap containing all items emitted by the finite source Publisher, + mapped by the keys returned by a specified keySelector function.
+
+
toMap(Function<? super T, ? extends K>, Function<? super T, ? extends V>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a single HashMap containing values corresponding to items emitted by the + finite source Publisher, mapped by the keys returned by a specified keySelector function.
+
+
toMap(Function<? super T, ? extends K>, Function<? super T, ? extends V>, Supplier<? extends Map<K, V>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a single Map, returned by a specified mapFactory function, that + contains keys and values extracted from the items emitted by the finite source Publisher.
+
+
toMap(Function<? super T, ? extends K>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a single HashMap containing all items emitted by the + current and finite Observable, mapped by the keys returned by a specified + keySelector function.
+
+
toMap(Function<? super T, ? extends K>, Function<? super T, ? extends V>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a single HashMap containing values corresponding to items emitted by the + current and finite Observable, mapped by the keys and values returned by the given selector functions.
+
+
toMap(Function<? super T, ? extends K>, Function<? super T, ? extends V>, Supplier<? extends Map<K, V>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that + contains keys and values extracted from the items, via selector functions, emitted by the current and finite Observable.
+
+
toMaybe() - Method in class io.reactivex.rxjava3.core.Completable
+
+
Converts this Completable into a Maybe.
+
+
toMaybe() - Method in class io.reactivex.rxjava3.core.Single
+
+
Converts this Single into a Maybe.
+
+
toMultimap(Function<? super T, ? extends K>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the + finite source Publisher keyed by a specified keySelector function.
+
+
toMultimap(Function<? super T, ? extends K>, Function<? super T, ? extends V>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a + specified valueSelector function from items emitted by the finite source Publisher, keyed by a + specified keySelector function.
+
+
toMultimap(Function<? super T, ? extends K>, Function<? super T, ? extends V>, Supplier<? extends Map<K, Collection<V>>>, Function<? super K, ? extends Collection<? super V>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a single Map, returned by a specified mapFactory function, that + contains a custom collection of values, extracted by a specified valueSelector function from + items emitted by the finite source Publisher, and keyed by the keySelector function.
+
+
toMultimap(Function<? super T, ? extends K>, Function<? super T, ? extends V>, Supplier<Map<K, Collection<V>>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a single Map, returned by a specified mapFactory function, that + contains an ArrayList of values, extracted by a specified valueSelector function from items + emitted by the finite source Publisher and keyed by the keySelector function.
+
+
toMultimap(Function<? super T, ? extends K>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the + current and finite Observable keyed by a specified keySelector function.
+
+
toMultimap(Function<? super T, ? extends K>, Function<? super T, ? extends V>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a + specified valueSelector function from items emitted by the current and finite Observable, + keyed by a specified keySelector function.
+
+
toMultimap(Function<? super T, ? extends K>, Function<? super T, ? extends V>, Supplier<? extends Map<K, Collection<V>>>, Function<? super K, ? extends Collection<? super V>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that + contains a custom Collection of values, extracted by a specified valueSelector function from + items emitted by the current and finite Observable, and keyed by the keySelector function.
+
+
toMultimap(Function<? super T, ? extends K>, Function<? super T, ? extends V>, Supplier<Map<K, Collection<V>>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that + contains an ArrayList of values, extracted by a specified valueSelector function from items + emitted by the current and finite Observable and keyed by the keySelector function.
+
+
toObservable() - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns an Observable which when subscribed to subscribes to this Completable and + relays the terminal events to the downstream Observer.
+
+
toObservable() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Converts the current Flowable into a non-backpressured Observable.
+
+
toObservable() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Converts this Maybe into an Observable instance composing disposal + through.
+
+
toObservable() - Method in class io.reactivex.rxjava3.core.Single
+
+
Converts this Single into an Observable.
+
+
toSerialized() - Method in class io.reactivex.rxjava3.processors.FlowableProcessor
+
+
Wraps this FlowableProcessor and serializes the calls to the onSubscribe, onNext, onError and + onComplete methods, making them thread-safe.
+
+
toSerialized() - Method in class io.reactivex.rxjava3.subjects.Subject
+
+
Wraps this Subject and serializes the calls to the onSubscribe, onNext, onError and + onComplete methods, making them thread-safe.
+
+
toSingle(Supplier<? extends T>) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Converts this Completable into a Single which when this Completable completes normally, + calls the given Supplier and emits its returned value through onSuccess.
+
+
toSingle() - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Converts this Maybe into a Single instance composing disposal + through and turning an empty Maybe into a signal of NoSuchElementException.
+
+
toSingleDefault(T) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Converts this Completable into a Single which when this Completable completes normally, + emits the given value through onSuccess.
+
+
toSortedList() - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a + sorted order.
+
+
toSortedList(Comparator<? super T>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a + sorted order based on a specified comparison function.
+
+
toSortedList(Comparator<? super T>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a + sorted order based on a specified comparison function.
+
+
toSortedList(int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a + sorted order.
+
+
toSortedList() - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a + sorted order.
+
+
toSortedList(Comparator<? super T>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a + sorted order based on a specified comparison function.
+
+
toSortedList(Comparator<? super T>, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a + sorted order based on a specified comparison function.
+
+
toSortedList(int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a + sorted order.
+
+
toSortedList(Comparator<? super T>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Sorts the 'rails' according to the comparator and returns a full sorted List as a Flowable.
+
+
toSortedList(Comparator<? super T>, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Sorts the 'rails' according to the comparator and returns a full sorted List as a Flowable.
+
+
toString() - Method in class io.reactivex.rxjava3.core.Notification
+
 
+
toString() - Method in class io.reactivex.rxjava3.schedulers.Timed
+
 
+
TRAMPOLINE - Static variable in annotation type io.reactivex.rxjava3.annotations.SchedulerSupport
+
+
The operator/class runs on RxJava's trampoline scheduler + or takes timing information from it.
+
+
trampoline() - Static method in class io.reactivex.rxjava3.schedulers.Schedulers
+
+
Returns a default, shared Scheduler instance whose Scheduler.Worker + instances queue work and execute them in a FIFO manner on one of the participating threads.
+
+
triggerActions() - Method in class io.reactivex.rxjava3.schedulers.TestScheduler
+
+
Triggers any actions that have not yet been triggered and that are scheduled to be triggered at or + before this Scheduler's present time.
+
+
tryOnError(Throwable) - Method in interface io.reactivex.rxjava3.core.CompletableEmitter
+
+
Attempts to emit the specified Throwable error if the downstream + hasn't cancelled the sequence or is otherwise terminated, returning false + if the emission is not allowed to happen due to lifecycle restrictions.
+
+
tryOnError(Throwable) - Method in interface io.reactivex.rxjava3.core.FlowableEmitter
+
+
Attempts to emit the specified Throwable error if the downstream + hasn't cancelled the sequence or is otherwise terminated, returning false + if the emission is not allowed to happen due to lifecycle restrictions.
+
+
tryOnError(Throwable) - Method in interface io.reactivex.rxjava3.core.MaybeEmitter
+
+
Attempts to emit the specified Throwable error if the downstream + hasn't cancelled the sequence or is otherwise terminated, returning false + if the emission is not allowed to happen due to lifecycle restrictions.
+
+
tryOnError(Throwable) - Method in interface io.reactivex.rxjava3.core.ObservableEmitter
+
+
Attempts to emit the specified Throwable error if the downstream + hasn't cancelled the sequence or is otherwise terminated, returning false + if the emission is not allowed to happen due to lifecycle restrictions.
+
+
tryOnError(Throwable) - Method in interface io.reactivex.rxjava3.core.SingleEmitter
+
+
Attempts to emit the specified Throwable error if the downstream + hasn't cancelled the sequence or is otherwise terminated, returning false + if the emission is not allowed to happen due to lifecycle restrictions.
+
+
tryOnNext(T) - Method in interface io.reactivex.rxjava3.operators.ConditionalSubscriber
+
+
Conditionally takes the value.
+
+
+ + + +

U

+
+
UndeliverableException - Exception in io.reactivex.rxjava3.exceptions
+
+
Wrapper for Throwable errors that are sent to RxJavaPlugins.onError.
+
+
UndeliverableException(Throwable) - Constructor for exception io.reactivex.rxjava3.exceptions.UndeliverableException
+
+
Construct an instance by wrapping the given, non-null + cause Throwable.
+
+
UnicastProcessor<T> - Class in io.reactivex.rxjava3.processors
+
+
A FlowableProcessor variant that queues up events until a single Subscriber subscribes to it, replays + those events to it until the Subscriber catches up and then switches to relaying events live to + this single Subscriber until this UnicastProcessor terminates or the Subscriber cancels + its subscription.
+
+
UnicastSubject<T> - Class in io.reactivex.rxjava3.subjects
+
+
A Subject that queues up events until a single Observer subscribes to it, replays + those events to it until the Observer catches up and then switches to relaying events live to + this single Observer until this UnicastSubject terminates or the Observer disposes.
+
+
unit() - Method in class io.reactivex.rxjava3.schedulers.Timed
+
+
Returns the time unit of the contained time.
+
+
unsafeCreate(CompletableSource) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Constructs a Completable instance by wrapping the given source callback + without any safeguards; you should manage the lifecycle and response + to downstream disposal.
+
+
unsafeCreate(Publisher<T>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Create a Flowable by wrapping a Publisher which has to be implemented according + to the Reactive Streams specification by handling backpressure and + cancellation correctly; no safeguards are provided by the Flowable itself.
+
+
unsafeCreate(MaybeSource<T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Advanced use only: creates a Maybe instance without + any safeguards by using a callback that is called with a MaybeObserver.
+
+
unsafeCreate(ObservableSource<T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Create an Observable by wrapping an ObservableSource which has to be implemented according + to the Observable specification derived from the Reactive Streams specification by handling + disposal correctly; no safeguards are provided by the Observable itself.
+
+
unsafeCreate(SingleSource<T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Advanced use only: creates a Single instance without + any safeguards by using a callback that is called with a SingleObserver.
+
+
unsubscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable which makes sure when an observer disposes the subscription, the + dispose() method is called on the specified Scheduler.
+
+
unsubscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Cancels the current Flowable asynchronously by invoking Subscription.cancel() + on the specified Scheduler.
+
+
unsubscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe which makes sure when a MaybeObserver disposes the Disposable, + that call is propagated up on the specified Scheduler.
+
+
unsubscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Return an Observable that schedules the downstream Observers' dispose calls + aimed at the current Observable on the given Scheduler.
+
+
unsubscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single which makes sure when a SingleObserver disposes the Disposable, + that call is propagated up on the specified Scheduler.
+
+
using(Supplier<R>, Function<? super R, ? extends CompletableSource>, Consumer<? super R>) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance which manages a resource along + with a custom CompletableSource instance while the subscription is active.
+
+
using(Supplier<R>, Function<? super R, ? extends CompletableSource>, Consumer<? super R>, boolean) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Returns a Completable instance which manages a resource along + with a custom CompletableSource instance while the subscription is active and performs eager or lazy + resource disposition.
+
+
using(Supplier<? extends D>, Function<? super D, ? extends Publisher<? extends T>>, Consumer<? super D>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Constructs a Flowable that creates a dependent resource object, a Publisher with + that resource and calls the provided resourceDisposer function if this inner source terminates or the + downstream cancels the flow.
+
+
using(Supplier<? extends D>, Function<? super D, ? extends Publisher<? extends T>>, Consumer<? super D>, boolean) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Constructs a Flowable that creates a dependent resource object, a Publisher with + that resource and calls the provided resourceDisposer function if this inner source terminates or the + downstream disposes the flow; doing it before these end-states have been reached if eager == true, after otherwise.
+
+
using(Supplier<? extends D>, Function<? super D, ? extends MaybeSource<? extends T>>, Consumer<? super D>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Constructs a Maybe that creates a dependent resource object which is disposed of when the + generated MaybeSource terminates or the downstream calls dispose().
+
+
using(Supplier<? extends D>, Function<? super D, ? extends MaybeSource<? extends T>>, Consumer<? super D>, boolean) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Constructs a Maybe that creates a dependent resource object which is disposed first ({code eager == true}) + when the generated MaybeSource terminates or the downstream disposes; or after ({code eager == false}).
+
+
using(Supplier<? extends D>, Function<? super D, ? extends ObservableSource<? extends T>>, Consumer<? super D>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Constructs an Observable that creates a dependent resource object, an ObservableSource with + that resource and calls the provided resourceDisposer function if this inner source terminates or the + downstream disposes the flow.
+
+
using(Supplier<? extends D>, Function<? super D, ? extends ObservableSource<? extends T>>, Consumer<? super D>, boolean) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Constructs an Observable that creates a dependent resource object, an ObservableSource with + that resource and calls the provided disposer function if this inner source terminates or the + downstream disposes the flow; doing it before these end-states have been reached if eager == true, after otherwise.
+
+
using(Supplier<U>, Function<? super U, ? extends SingleSource<? extends T>>, Consumer<? super U>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Allows using and disposing a resource while running a SingleSource instance generated from + that resource (similar to a try-with-resources).
+
+
using(Supplier<U>, Function<? super U, ? extends SingleSource<? extends T>>, Consumer<? super U>, boolean) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Allows using and disposing a resource while running a SingleSource instance generated from + that resource (similar to a try-with-resources).
+
+
+ + + +

V

+
+
validate(Subscriber<?>[]) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable
+
+
Validates the number of subscribers and returns true if their number + matches the parallelism level of this ParallelFlowable.
+
+
value() - Method in class io.reactivex.rxjava3.schedulers.Timed
+
+
Returns the contained value.
+
+
valueAndClass(Object) - Static method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Appends the class name to a non-null value or returns "null".
+
+
valueOf(String) - Static method in enum io.reactivex.rxjava3.annotations.BackpressureKind
+
+
Returns the enum constant of this type with the specified name.
+
+
valueOf(String) - Static method in enum io.reactivex.rxjava3.core.BackpressureOverflowStrategy
+
+
Returns the enum constant of this type with the specified name.
+
+
valueOf(String) - Static method in enum io.reactivex.rxjava3.core.BackpressureStrategy
+
+
Returns the enum constant of this type with the specified name.
+
+
valueOf(String) - Static method in enum io.reactivex.rxjava3.parallel.ParallelFailureHandling
+
+
Returns the enum constant of this type with the specified name.
+
+
values() - Static method in enum io.reactivex.rxjava3.annotations.BackpressureKind
+
+
Returns an array containing the constants of this enum type, in +the order they are declared.
+
+
values() - Static method in enum io.reactivex.rxjava3.core.BackpressureOverflowStrategy
+
+
Returns an array containing the constants of this enum type, in +the order they are declared.
+
+
values() - Static method in enum io.reactivex.rxjava3.core.BackpressureStrategy
+
+
Returns an array containing the constants of this enum type, in +the order they are declared.
+
+
values - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
The list of values received.
+
+
values() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Returns a shared list of received onNext values or the single onSuccess value.
+
+
values() - Static method in enum io.reactivex.rxjava3.parallel.ParallelFailureHandling
+
+
Returns an array containing the constants of this enum type, in +the order they are declared.
+
+
+ + + +

W

+
+
when(Function<Flowable<Flowable<Completable>>, Completable>) - Method in class io.reactivex.rxjava3.core.Scheduler
+
+
Allows the use of operators for controlling the timing around when + actions scheduled on workers are actually done.
+
+
window(long) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits windows of items it collects from the current Flowable.
+
+
window(long, long) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits windows of items it collects from the current Flowable.
+
+
window(long, long, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits windows of items it collects from the current Flowable.
+
+
window(long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits windows of items it collects from the current Flowable.
+
+
window(long, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits windows of items it collects from the current Flowable.
+
+
window(long, long, TimeUnit, Scheduler, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits windows of items it collects from the current Flowable.
+
+
window(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits windows of items it collects from the current Flowable.
+
+
window(long, TimeUnit, long) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits windows of items it collects from the current Flowable.
+
+
window(long, TimeUnit, long, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits windows of items it collects from the current Flowable.
+
+
window(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits windows of items it collects from the current Flowable.
+
+
window(long, TimeUnit, Scheduler, long) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits windows of items it collects from the current Flowable.
+
+
window(long, TimeUnit, Scheduler, long, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits windows of items it collects from the current Flowable.
+
+
window(long, TimeUnit, Scheduler, long, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits windows of items it collects from the current Flowable.
+
+
window(Publisher<B>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits non-overlapping windows of items it collects from the current Flowable + where the boundary of each window is determined by the items emitted from a specified boundary-governing + Publisher.
+
+
window(Publisher<B>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits non-overlapping windows of items it collects from the current Flowable + where the boundary of each window is determined by the items emitted from a specified boundary-governing + Publisher.
+
+
window(Publisher<U>, Function<? super U, ? extends Publisher<V>>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits windows of items it collects from the current Flowable.
+
+
window(Publisher<U>, Function<? super U, ? extends Publisher<V>>, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits windows of items it collects from the current Flowable.
+
+
window(long) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits windows of items it collects from the current Observable.
+
+
window(long, long) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits windows of items it collects from the current Observable.
+
+
window(long, long, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits windows of items it collects from the current Observable.
+
+
window(long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits windows of items it collects from the current Observable.
+
+
window(long, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits windows of items it collects from the current Observable.
+
+
window(long, long, TimeUnit, Scheduler, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits windows of items it collects from the current Observable.
+
+
window(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits windows of items it collects from the current Observable.
+
+
window(long, TimeUnit, long) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits windows of items it collects from the current Observable.
+
+
window(long, TimeUnit, long, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits windows of items it collects from the current Observable.
+
+
window(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits windows of items it collects from the current Observable.
+
+
window(long, TimeUnit, Scheduler, long) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits windows of items it collects from the current Observable.
+
+
window(long, TimeUnit, Scheduler, long, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits windows of items it collects from the current Observable.
+
+
window(long, TimeUnit, Scheduler, long, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits windows of items it collects from the current Observable.
+
+
window(ObservableSource<B>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits non-overlapping windows of items it collects from the current Observable + where the boundary of each window is determined by the items emitted from a specified boundary-governing + ObservableSource.
+
+
window(ObservableSource<B>, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits non-overlapping windows of items it collects from the current Observable + where the boundary of each window is determined by the items emitted from a specified boundary-governing + ObservableSource.
+
+
window(ObservableSource<U>, Function<? super U, ? extends ObservableSource<V>>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits windows of items it collects from the current Observable.
+
+
window(ObservableSource<U>, Function<? super U, ? extends ObservableSource<V>>, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits windows of items it collects from the current Observable.
+
+
withLatestFrom(Publisher<? extends U>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Merges the specified Publisher into the current Flowable sequence by using the resultSelector + function only when the current Flowable (this instance) emits an item.
+
+
withLatestFrom(Publisher<T1>, Publisher<T2>, Function3<? super T, ? super T1, ? super T2, R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines the value emission from the current Flowable with the latest emissions from the + other Publishers via a function to produce the output item.
+
+
withLatestFrom(Publisher<T1>, Publisher<T2>, Publisher<T3>, Function4<? super T, ? super T1, ? super T2, ? super T3, R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines the value emission from the current Flowable with the latest emissions from the + other Publishers via a function to produce the output item.
+
+
withLatestFrom(Publisher<T1>, Publisher<T2>, Publisher<T3>, Publisher<T4>, Function5<? super T, ? super T1, ? super T2, ? super T3, ? super T4, R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines the value emission from the current Flowable with the latest emissions from the + other Publishers via a function to produce the output item.
+
+
withLatestFrom(Publisher<?>[], Function<? super Object[], R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines the value emission from the current Flowable with the latest emissions from the + other Publishers via a function to produce the output item.
+
+
withLatestFrom(Iterable<? extends Publisher<?>>, Function<? super Object[], R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Combines the value emission from the current Flowable with the latest emissions from the + other Publishers via a function to produce the output item.
+
+
withLatestFrom(ObservableSource<? extends U>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Merges the specified ObservableSource into the current Observable sequence by using the resultSelector + function only when the current Observable emits an item.
+
+
withLatestFrom(ObservableSource<T1>, ObservableSource<T2>, Function3<? super T, ? super T1, ? super T2, R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Combines the value emission from the current Observable with the latest emissions from the + other ObservableSources via a function to produce the output item.
+
+
withLatestFrom(ObservableSource<T1>, ObservableSource<T2>, ObservableSource<T3>, Function4<? super T, ? super T1, ? super T2, ? super T3, R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Combines the value emission from the current Observable with the latest emissions from the + other ObservableSources via a function to produce the output item.
+
+
withLatestFrom(ObservableSource<T1>, ObservableSource<T2>, ObservableSource<T3>, ObservableSource<T4>, Function5<? super T, ? super T1, ? super T2, ? super T3, ? super T4, R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Combines the value emission from the current Observable with the latest emissions from the + other ObservableSources via a function to produce the output item.
+
+
withLatestFrom(ObservableSource<?>[], Function<? super Object[], R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Combines the value emission from the current Observable with the latest emissions from the + other ObservableSources via a function to produce the output item.
+
+
withLatestFrom(Iterable<? extends ObservableSource<?>>, Function<? super Object[], R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Combines the value emission from the current Observable with the latest emissions from the + other ObservableSources via a function to produce the output item.
+
+
withTag(CharSequence) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer
+
+
Set the tag displayed along with an assertion failure's + other state information.
+
+
Worker() - Constructor for class io.reactivex.rxjava3.core.Scheduler.Worker
+
 
+
wrap(CompletableSource) - Static method in class io.reactivex.rxjava3.core.Completable
+
+
Wraps the given CompletableSource into a Completable + if not already Completable.
+
+
wrap(MaybeSource<T>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Wraps a MaybeSource instance into a new Maybe instance if not already a Maybe + instance.
+
+
wrap(ObservableSource<T>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Wraps an ObservableSource into an Observable if not already an Observable.
+
+
wrap(SingleSource<T>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Wraps a SingleSource instance into a new Single instance if not already a Single + instance.
+
+
+ + + +

Z

+
+
zip(Iterable<? extends Publisher<? extends T>>, Function<? super Object[], ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an Iterable of other Publishers.
+
+
zip(Iterable<? extends Publisher<? extends T>>, Function<? super Object[], ? extends R>, boolean, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an Iterable of other Publishers.
+
+
zip(Publisher<? extends T1>, Publisher<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified combiner function applied to combinations of + two items emitted, in sequence, by two other Publishers.
+
+
zip(Publisher<? extends T1>, Publisher<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>, boolean) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified combiner function applied to combinations of + two items emitted, in sequence, by two other Publishers.
+
+
zip(Publisher<? extends T1>, Publisher<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>, boolean, int) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified combiner function applied to combinations of + two items emitted, in sequence, by two other Publishers.
+
+
zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Function3<? super T1, ? super T2, ? super T3, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified combiner function applied to combinations of + three items emitted, in sequence, by three other Publishers.
+
+
zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified combiner function applied to combinations of + four items emitted, in sequence, by four other Publishers.
+
+
zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified combiner function applied to combinations of + five items emitted, in sequence, by five other Publishers.
+
+
zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>, Publisher<? extends T6>, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified combiner function applied to combinations of + six items emitted, in sequence, by six other Publishers.
+
+
zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>, Publisher<? extends T6>, Publisher<? extends T7>, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified combiner function applied to combinations of + seven items emitted, in sequence, by seven other Publishers.
+
+
zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>, Publisher<? extends T6>, Publisher<? extends T7>, Publisher<? extends T8>, Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified combiner function applied to combinations of + eight items emitted, in sequence, by eight other Publishers.
+
+
zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>, Publisher<? extends T6>, Publisher<? extends T7>, Publisher<? extends T8>, Publisher<? extends T9>, Function9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified combiner function applied to combinations of + nine items emitted, in sequence, by nine other Publishers.
+
+
zip(Iterable<? extends MaybeSource<? extends T>>, Function<? super Object[], ? extends R>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an Iterable of other MaybeSources.
+
+
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits the results of a specified combiner function applied to combinations of + two items emitted, in sequence, by two other MaybeSources.
+
+
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, MaybeSource<? extends T3>, Function3<? super T1, ? super T2, ? super T3, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits the results of a specified combiner function applied to combinations of + three items emitted, in sequence, by three other MaybeSources.
+
+
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, MaybeSource<? extends T3>, MaybeSource<? extends T4>, Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits the results of a specified combiner function applied to combinations of + four items emitted, in sequence, by four other MaybeSources.
+
+
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, MaybeSource<? extends T3>, MaybeSource<? extends T4>, MaybeSource<? extends T5>, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits the results of a specified combiner function applied to combinations of + five items emitted, in sequence, by five other MaybeSources.
+
+
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, MaybeSource<? extends T3>, MaybeSource<? extends T4>, MaybeSource<? extends T5>, MaybeSource<? extends T6>, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits the results of a specified combiner function applied to combinations of + six items emitted, in sequence, by six other MaybeSources.
+
+
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, MaybeSource<? extends T3>, MaybeSource<? extends T4>, MaybeSource<? extends T5>, MaybeSource<? extends T6>, MaybeSource<? extends T7>, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits the results of a specified combiner function applied to combinations of + seven items emitted, in sequence, by seven other MaybeSources.
+
+
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, MaybeSource<? extends T3>, MaybeSource<? extends T4>, MaybeSource<? extends T5>, MaybeSource<? extends T6>, MaybeSource<? extends T7>, MaybeSource<? extends T8>, Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits the results of a specified combiner function applied to combinations of + eight items emitted, in sequence, by eight other MaybeSources.
+
+
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, MaybeSource<? extends T3>, MaybeSource<? extends T4>, MaybeSource<? extends T5>, MaybeSource<? extends T6>, MaybeSource<? extends T7>, MaybeSource<? extends T8>, MaybeSource<? extends T9>, Function9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits the results of a specified combiner function applied to combinations of + nine items emitted, in sequence, by nine other MaybeSources.
+
+
zip(Iterable<? extends ObservableSource<? extends T>>, Function<? super Object[], ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an Iterable of other ObservableSources.
+
+
zip(Iterable<? extends ObservableSource<? extends T>>, Function<? super Object[], ? extends R>, boolean, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an Iterable of other ObservableSources.
+
+
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified combiner function applied to combinations of + two items emitted, in sequence, by two other ObservableSources.
+
+
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>, boolean) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified combiner function applied to combinations of + two items emitted, in sequence, by two other ObservableSources.
+
+
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>, boolean, int) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified combiner function applied to combinations of + two items emitted, in sequence, by two other ObservableSources.
+
+
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, Function3<? super T1, ? super T2, ? super T3, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified combiner function applied to combinations of + three items emitted, in sequence, by three other ObservableSources.
+
+
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified combiner function applied to combinations of + four items emitted, in sequence, by four other ObservableSources.
+
+
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified combiner function applied to combinations of + five items emitted, in sequence, by five other ObservableSources.
+
+
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified combiner function applied to combinations of + six items emitted, in sequence, by six other ObservableSources.
+
+
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, ObservableSource<? extends T7>, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified combiner function applied to combinations of + seven items emitted, in sequence, by seven other ObservableSources.
+
+
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, ObservableSource<? extends T7>, ObservableSource<? extends T8>, Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified combiner function applied to combinations of + eight items emitted, in sequence, by eight other ObservableSources.
+
+
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, ObservableSource<? extends T7>, ObservableSource<? extends T8>, ObservableSource<? extends T9>, Function9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified combiner function applied to combinations of + nine items emitted, in sequence, by nine other ObservableSources.
+
+
zip(Iterable<? extends SingleSource<? extends T>>, Function<? super Object[], ? extends R>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Waits until all SingleSource sources provided by the Iterable sequence signal a success + value and calls a zipper function with an array of these values to return a result + to be emitted to the downstream.
+
+
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that emits the results of a specified combiner function applied to two items emitted by + two other SingleSources.
+
+
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, SingleSource<? extends T3>, Function3<? super T1, ? super T2, ? super T3, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that emits the results of a specified combiner function applied to three items emitted + by three other SingleSources.
+
+
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, SingleSource<? extends T3>, SingleSource<? extends T4>, Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that emits the results of a specified combiner function applied to four items + emitted by four other SingleSources.
+
+
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, SingleSource<? extends T3>, SingleSource<? extends T4>, SingleSource<? extends T5>, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that emits the results of a specified combiner function applied to five items + emitted by five other SingleSources.
+
+
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, SingleSource<? extends T3>, SingleSource<? extends T4>, SingleSource<? extends T5>, SingleSource<? extends T6>, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that emits the results of a specified combiner function applied to six items + emitted by six other SingleSources.
+
+
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, SingleSource<? extends T3>, SingleSource<? extends T4>, SingleSource<? extends T5>, SingleSource<? extends T6>, SingleSource<? extends T7>, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that emits the results of a specified combiner function applied to seven items + emitted by seven other SingleSources.
+
+
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, SingleSource<? extends T3>, SingleSource<? extends T4>, SingleSource<? extends T5>, SingleSource<? extends T6>, SingleSource<? extends T7>, SingleSource<? extends T8>, Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that emits the results of a specified combiner function applied to eight items + emitted by eight other SingleSources.
+
+
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, SingleSource<? extends T3>, SingleSource<? extends T4>, SingleSource<? extends T5>, SingleSource<? extends T6>, SingleSource<? extends T7>, SingleSource<? extends T8>, SingleSource<? extends T9>, Function9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R>) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that emits the results of a specified combiner function applied to nine items + emitted by nine other SingleSources.
+
+
zipArray(Function<? super Object[], ? extends R>, boolean, int, Publisher<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an array of other Publishers.
+
+
zipArray(Function<? super Object[], ? extends R>, MaybeSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Maybe
+
+
Returns a Maybe that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an array of other MaybeSources.
+
+
zipArray(Function<? super Object[], ? extends R>, boolean, int, ObservableSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an array of other ObservableSources.
+
+
zipArray(Function<? super Object[], ? extends R>, SingleSource<? extends T>...) - Static method in class io.reactivex.rxjava3.core.Single
+
+
Waits until all SingleSource sources provided via an array signal a success + value and calls a zipper function with an array of these values to return a result + to be emitted to downstream.
+
+
zipWith(Iterable<U>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Flowable and a specified Iterable sequence.
+
+
zipWith(Publisher<? extends U>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Flowable and another specified Publisher.
+
+
zipWith(Publisher<? extends U>, BiFunction<? super T, ? super U, ? extends R>, boolean) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Flowable and another specified Publisher.
+
+
zipWith(Publisher<? extends U>, BiFunction<? super T, ? super U, ? extends R>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable
+
+
Returns a Flowable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Flowable and another specified Publisher.
+
+
zipWith(MaybeSource<? extends U>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.rxjava3.core.Maybe
+
+
Waits until this and the other MaybeSource signal a success value then applies the given BiFunction + to those values and emits the BiFunction's resulting value to downstream.
+
+
zipWith(Iterable<U>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Observable and a specified Iterable sequence.
+
+
zipWith(ObservableSource<? extends U>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Observable and another specified ObservableSource.
+
+
zipWith(ObservableSource<? extends U>, BiFunction<? super T, ? super U, ? extends R>, boolean) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Observable and another specified ObservableSource.
+
+
zipWith(ObservableSource<? extends U>, BiFunction<? super T, ? super U, ? extends R>, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable
+
+
Returns an Observable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Observable and another specified ObservableSource.
+
+
zipWith(SingleSource<U>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.rxjava3.core.Single
+
+
Returns a Single that emits the result of applying a specified function to the pair of items emitted by + the current Single and another specified SingleSource.
+
+
+A B C D E F G H I J L M N O P Q R S T U V W Z 
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/index.html b/3.x/javadoc/3.1.8/index.html new file mode 100644 index 0000000000..a26f959b1a --- /dev/null +++ b/3.x/javadoc/3.1.8/index.html @@ -0,0 +1,75 @@ + + + + + +RxJava Javadoc 3.1.8 + + + + + + + + + +<noscript> +<div>JavaScript is disabled on your browser.</div> +</noscript> +<h2>Frame Alert</h2> +<p>This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client. Link to <a href="overview-summary.html">Non-frame version</a>.</p> + + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/BackpressureKind.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/BackpressureKind.html new file mode 100644 index 0000000000..f565df8ea2 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/BackpressureKind.html @@ -0,0 +1,415 @@ + + + + + +BackpressureKind (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + +
+
io.reactivex.rxjava3.annotations
+

Enum BackpressureKind

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Enum Constant Detail

      + + + +
        +
      • +

        PASS_THROUGH

        +
        public static final BackpressureKind PASS_THROUGH
        +
        The backpressure-related requests pass through this operator without change.
        +
        • +
      + + + +
        +
      • +

        FULL

        +
        public static final BackpressureKind FULL
        +
        The operator fully supports backpressure and may coordinate downstream requests + with upstream requests through batching, arbitration or by other means.
        +
        • +
      + + + +
        +
      • +

        SPECIAL

        +
        public static final BackpressureKind SPECIAL
        +
        The operator performs special backpressure management; see the associated javadoc.
        +
        • +
      + + + +
        +
      • +

        UNBOUNDED_IN

        +
        public static final BackpressureKind UNBOUNDED_IN
        +
        The operator requests Long.MAX_VALUE from upstream but respects the backpressure + of the downstream.
        +
        • +
      + + + + + + + +
        +
      • +

        NONE

        +
        public static final BackpressureKind NONE
        +
        The operator ignores all kinds of backpressure and may overflow the downstream.
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        values

        +
        public static BackpressureKind[] values()
        +
        Returns an array containing the constants of this enum type, in +the order they are declared. This method may be used to iterate +over the constants as follows: +
        +for (BackpressureKind c : BackpressureKind.values())
+    System.out.println(c);
+
        +
        +
        Returns:
        +
        an array containing the constants of this enum type, in the order they are declared
        +
        +
        • +
      + + + +
        +
      • +

        valueOf

        +
        public static BackpressureKind valueOf(String name)
        +
        Returns the enum constant of this type with the specified name. +The string must match exactly an identifier used to declare an +enum constant in this type. (Extraneous whitespace characters are +not permitted.)
        +
        +
        Parameters:
        +
        name - the name of the enum constant to be returned.
        +
        Returns:
        +
        the enum constant with the specified name
        +
        Throws:
        +
        IllegalArgumentException - if this enum type has no constant with the specified name
        +
        NullPointerException - if the argument is null
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/BackpressureSupport.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/BackpressureSupport.html new file mode 100644 index 0000000000..0901060c06 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/BackpressureSupport.html @@ -0,0 +1,223 @@ + + + + + +BackpressureSupport (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Field | 
    • +
  • Required | 
    • +
  • Optional
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.annotations
+

Annotation Type BackpressureSupport

+
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Required Element Summary

      + + + + + + + + + + +
      Required Elements 
      Modifier and TypeRequired Element and Description
      BackpressureKindvalue +
      The backpressure supported by this method or class.
      +
      +
      • +
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Element Detail

      + + + +
        +
      • +

        value

        +
        public abstract BackpressureKind value
        +
        The backpressure supported by this method or class.
        +
        +
        Returns:
        +
        backpressure supported by this method or class.
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Field | 
    • +
  • Required | 
    • +
  • Optional
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/Beta.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/Beta.html new file mode 100644 index 0000000000..77eb7f4c8b --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/Beta.html @@ -0,0 +1,162 @@ + + + + + +Beta (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Field | 
    • +
  • Required | 
    • +
  • Optional
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Element
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.annotations
+

Annotation Type Beta

+
+
+
+
    +
  • +
    +
    +
    public @interface Beta
    +
    Indicates the feature is in beta state: it will be most likely stay but + the signature may change between versions without warning.
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Field | 
    • +
  • Required | 
    • +
  • Optional
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Element
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/CheckReturnValue.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/CheckReturnValue.html new file mode 100644 index 0000000000..df072dbd4f --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/CheckReturnValue.html @@ -0,0 +1,169 @@ + + + + + +CheckReturnValue (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Field | 
    • +
  • Required | 
    • +
  • Optional
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Element
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.annotations
+

Annotation Type CheckReturnValue

+
+
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Field | 
    • +
  • Required | 
    • +
  • Optional
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Element
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/Experimental.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/Experimental.html new file mode 100644 index 0000000000..ec0bb89f64 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/Experimental.html @@ -0,0 +1,162 @@ + + + + + +Experimental (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Field | 
    • +
  • Required | 
    • +
  • Optional
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Element
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.annotations
+

Annotation Type Experimental

+
+
+
+
    +
  • +
    +
    +
    public @interface Experimental
    +
    Indicates the feature is in experimental state: its existence, signature or behavior + might change without warning from one release to the next.
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Field | 
    • +
  • Required | 
    • +
  • Optional
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Element
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/NonNull.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/NonNull.html new file mode 100644 index 0000000000..c3eea792bf --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/NonNull.html @@ -0,0 +1,164 @@ + + + + + +NonNull (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Field | 
    • +
  • Required | 
    • +
  • Optional
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Element
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.annotations
+

Annotation Type NonNull

+
+
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Field | 
    • +
  • Required | 
    • +
  • Optional
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Element
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/Nullable.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/Nullable.html new file mode 100644 index 0000000000..295602e48f --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/Nullable.html @@ -0,0 +1,164 @@ + + + + + +Nullable (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Field | 
    • +
  • Required | 
    • +
  • Optional
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Element
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.annotations
+

Annotation Type Nullable

+
+
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Field | 
    • +
  • Required | 
    • +
  • Optional
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Element
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/SchedulerSupport.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/SchedulerSupport.html new file mode 100644 index 0000000000..6b58beafe2 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/SchedulerSupport.html @@ -0,0 +1,396 @@ + + + + + +SchedulerSupport (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + +
+
io.reactivex.rxjava3.annotations
+

Annotation Type SchedulerSupport

+
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Field Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      Fields 
      Modifier and TypeFields and Description
      static StringCOMPUTATION +
      The operator/class runs on RxJava's computation + scheduler or takes timing information from it.
      +
      static StringCUSTOM +
      A special value indicating the operator/class requires a scheduler to be manually specified.
      +
      static StringIO +
      The operator/class runs on RxJava's I/O scheduler or takes + timing information from it.
      +
      static StringNEW_THREAD +
      The operator/class runs on RxJava's new thread scheduler + or takes timing information from it.
      +
      static StringNONE +
      A special value indicating the operator/class doesn't use schedulers.
      +
      static StringSINGLE +
      The operator/class runs on RxJava's single scheduler + or takes timing information from it.
      +
      static StringTRAMPOLINE +
      The operator/class runs on RxJava's trampoline scheduler + or takes timing information from it.
      +
      +
      • +
    + +
      +
    • + + +

      Required Element Summary

      + + + + + + + + + + +
      Required Elements 
      Modifier and TypeRequired Element and Description
      Stringvalue +
      The kind of scheduler the class or method uses.
      +
      +
      • +
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        NONE

        +
        public static final String NONE
        +
        A special value indicating the operator/class doesn't use schedulers.
        +
        • +
      +
      • +
    +
      +
    • + + +
        +
      • +

        CUSTOM

        +
        public static final String CUSTOM
        +
        A special value indicating the operator/class requires a scheduler to be manually specified.
        +
        • +
      +
      • +
    +
      +
    • + + +
        +
      • +

        COMPUTATION

        +
        public static final String COMPUTATION
        +
        The operator/class runs on RxJava's computation + scheduler or takes timing information from it.
        +
        • +
      +
      • +
    +
      +
    • + + +
        +
      • +

        IO

        +
        public static final String IO
        +
        The operator/class runs on RxJava's I/O scheduler or takes + timing information from it.
        +
        • +
      +
      • +
    +
      +
    • + + +
        +
      • +

        NEW_THREAD

        +
        public static final String NEW_THREAD
        +
        The operator/class runs on RxJava's new thread scheduler + or takes timing information from it.
        +
        • +
      +
      • +
    +
      +
    • + + +
        +
      • +

        TRAMPOLINE

        +
        public static final String TRAMPOLINE
        +
        The operator/class runs on RxJava's trampoline scheduler + or takes timing information from it.
        +
        • +
      +
      • +
    +
      +
    • + + +
        +
      • +

        SINGLE

        +
        public static final String SINGLE
        +
        The operator/class runs on RxJava's single scheduler + or takes timing information from it. +

        History: 2.0.8 - experimental

        +
        +
        Since:
        +
        2.2
        +
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Element Detail

      + + + +
        +
      • +

        value

        +
        public abstract String value
        +
        The kind of scheduler the class or method uses.
        +
        +
        Returns:
        +
        the name of the scheduler the class or method uses
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/package-frame.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/package-frame.html new file mode 100644 index 0000000000..32ec324359 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/package-frame.html @@ -0,0 +1,29 @@ + + + + + +io.reactivex.rxjava3.annotations (RxJava Javadoc 3.1.8) + + + + +

io.reactivex.rxjava3.annotations

+
+

Enums

+ +

Annotation Types

+ +
+ + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/package-summary.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/package-summary.html new file mode 100644 index 0000000000..1bac31e38b --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/package-summary.html @@ -0,0 +1,209 @@ + + + + + +io.reactivex.rxjava3.annotations (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Package io.reactivex.rxjava3.annotations

+
+
Annotations for indicating operator behavior, API stability + (@Experimental and @Beta) and + nullability indicators (Nullable and NonNull).
+
+

See: Description

+
+
+ + + + +

Package io.reactivex.rxjava3.annotations Description

+
Annotations for indicating operator behavior, API stability + (@Experimental and @Beta) and + nullability indicators (Nullable and NonNull).
+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/package-tree.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/package-tree.html new file mode 100644 index 0000000000..b12c50e6bf --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/annotations/package-tree.html @@ -0,0 +1,148 @@ + + + + + +io.reactivex.rxjava3.annotations Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For Package io.reactivex.rxjava3.annotations

+Package Hierarchies: + +
+
+

Annotation Type Hierarchy

+ +

Enum Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/BackpressureOverflowStrategy.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/BackpressureOverflowStrategy.html new file mode 100644 index 0000000000..da0578f2a7 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/BackpressureOverflowStrategy.html @@ -0,0 +1,362 @@ + + + + + +BackpressureOverflowStrategy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Enum BackpressureOverflowStrategy

+
+
+ +
+ +
+
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        values

        +
        public static BackpressureOverflowStrategy[] values()
        +
        Returns an array containing the constants of this enum type, in +the order they are declared. This method may be used to iterate +over the constants as follows: +
        +for (BackpressureOverflowStrategy c : BackpressureOverflowStrategy.values())
+    System.out.println(c);
+
        +
        +
        Returns:
        +
        an array containing the constants of this enum type, in the order they are declared
        +
        +
        • +
      + + + +
        +
      • +

        valueOf

        +
        public static BackpressureOverflowStrategy valueOf(String name)
        +
        Returns the enum constant of this type with the specified name. +The string must match exactly an identifier used to declare an +enum constant in this type. (Extraneous whitespace characters are +not permitted.)
        +
        +
        Parameters:
        +
        name - the name of the enum constant to be returned.
        +
        Returns:
        +
        the enum constant with the specified name
        +
        Throws:
        +
        IllegalArgumentException - if this enum type has no constant with the specified name
        +
        NullPointerException - if the argument is null
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/BackpressureStrategy.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/BackpressureStrategy.html new file mode 100644 index 0000000000..759c6f848b --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/BackpressureStrategy.html @@ -0,0 +1,396 @@ + + + + + +BackpressureStrategy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Enum BackpressureStrategy

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Enum Constant Detail

      + + + +
        +
      • +

        MISSING

        +
        public static final BackpressureStrategy MISSING
        +
        The onNext events are written without any buffering or dropping. + Downstream has to deal with any overflow. +

        Useful when one applies one of the custom-parameter onBackpressureXXX operators.

        +
        • +
      + + + + + + + +
        +
      • +

        BUFFER

        +
        public static final BackpressureStrategy BUFFER
        +
        Buffers all onNext values until the downstream consumes it.
        +
        • +
      + + + +
        +
      • +

        DROP

        +
        public static final BackpressureStrategy DROP
        +
        Drops the most recent onNext value if the downstream can't keep up.
        +
        • +
      + + + +
        +
      • +

        LATEST

        +
        public static final BackpressureStrategy LATEST
        +
        Keeps only the latest onNext value, overwriting any previous value if the + downstream can't keep up.
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        values

        +
        public static BackpressureStrategy[] values()
        +
        Returns an array containing the constants of this enum type, in +the order they are declared. This method may be used to iterate +over the constants as follows: +
        +for (BackpressureStrategy c : BackpressureStrategy.values())
+    System.out.println(c);
+
        +
        +
        Returns:
        +
        an array containing the constants of this enum type, in the order they are declared
        +
        +
        • +
      + + + +
        +
      • +

        valueOf

        +
        public static BackpressureStrategy valueOf(String name)
        +
        Returns the enum constant of this type with the specified name. +The string must match exactly an identifier used to declare an +enum constant in this type. (Extraneous whitespace characters are +not permitted.)
        +
        +
        Parameters:
        +
        name - the name of the enum constant to be returned.
        +
        Returns:
        +
        the enum constant with the specified name
        +
        Throws:
        +
        IllegalArgumentException - if this enum type has no constant with the specified name
        +
        NullPointerException - if the argument is null
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Completable.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Completable.html new file mode 100644 index 0000000000..ed0fc43e22 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Completable.html @@ -0,0 +1,5392 @@ + + + + + +Completable (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Class Completable

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    CompletableSource
    +
    +
    +
    Direct Known Subclasses:
    +
    CompletableSubject
    +
    +
    +
    +
    public abstract class Completable
+extends Object
+implements CompletableSource
    +
    The Completable class represents a deferred computation without any value but + only indication for completion or exception. +

    + Completable behaves similarly to Observable except that it can only emit either + a completion or error signal (there is no onNext or onSuccess as with the other + reactive types). +

    + The Completable class implements the CompletableSource base interface and the default consumer + type it interacts with is the CompletableObserver via the subscribe(CompletableObserver) method. + The Completable operates with the following sequential protocol: + 

    
+     onSubscribe (onError | onComplete)?
+
    +

    + Note that as with the Observable protocol, onError and onComplete are mutually exclusive events. +

    + Like Observable, a running Completable can be stopped through the Disposable instance + provided to consumers through CompletableObserver.onSubscribe(io.reactivex.rxjava3.disposables.Disposable). +

    + Like an Observable, a Completable is lazy, can be either "hot" or "cold", synchronous or + asynchronous. Completable instances returned by the methods of this class are cold + and there is a standard hot implementation in the form of a subject: + CompletableSubject. +

    + The documentation for this class makes use of marble diagrams. The following legend explains these diagrams: +

    + +

    + See Flowable or Observable for the + implementation of the Reactive Pattern for a stream or vector of values. +

    + Example: + 

    
+ Disposable d = Completable.complete()
+    .delay(10, TimeUnit.SECONDS, Schedulers.io())
+    .subscribeWith(new DisposableCompletableObserver() {
+        @Override
+        public void onStart() {
+            System.out.println("Started");
+        }
+
+        @Override
+        public void onError(Throwable error) {
+            error.printStackTrace();
+        }
+
+        @Override
+        public void onComplete() {
+            System.out.println("Done!");
+        }
+    });
+ 
+ Thread.sleep(5000);
+ 
+ d.dispose();
+
    +

    + Note that by design, subscriptions via subscribe(CompletableObserver) can't be disposed + from the outside (hence the + void return of the subscribe(CompletableObserver) method) and it is the + responsibility of the implementor of the CompletableObserver to allow this to happen. + RxJava supports such usage with the standard + DisposableCompletableObserver instance. + For convenience, the subscribeWith(CompletableObserver) method is provided as well to + allow working with a CompletableObserver (or subclass) instance to be applied with in + a fluent manner (such as in the example above).

    +
    +
    See Also:
    +
    DisposableCompletableObserver
    +
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableConverter.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableConverter.html new file mode 100644 index 0000000000..636fc777df --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableConverter.html @@ -0,0 +1,244 @@ + + + + + +CompletableConverter (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface CompletableConverter<R>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    R - the output type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface CompletableConverter<R>
    +
    Convenience interface and callback used by the Completable.to(io.reactivex.rxjava3.core.CompletableConverter<? extends R>) operator to turn a Completable into another + value fluently. +

    History: 2.1.7 - experimental

    +
    +
    Since:
    +
    2.2
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        apply

        +
        R apply(@NonNull
+        @NonNull Completable upstream)
        +
        Applies a function to the upstream Completable and returns a converted value of type R.
        +
        +
        Parameters:
        +
        upstream - the upstream Completable instance
        +
        Returns:
        +
        the converted value
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableEmitter.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableEmitter.html new file mode 100644 index 0000000000..21ce59937b --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableEmitter.html @@ -0,0 +1,373 @@ + + + + + +CompletableEmitter (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface CompletableEmitter

+
+
+
+
    +
  • +
    +
    +
    public interface CompletableEmitter
    +
    Abstraction over an RxJava CompletableObserver that allows associating + a resource with it. +

    + All methods are safe to call from multiple threads, but note that there is no guarantee + whose terminal event will win and get delivered to the downstream. +

    + Calling onComplete() multiple times has no effect. + Calling onError(Throwable) multiple times or after onComplete will route the + exception into the global error handler via RxJavaPlugins.onError(Throwable). +

    + The emitter allows the registration of a single resource, in the form of a Disposable + or Cancellable via setDisposable(Disposable) or setCancellable(Cancellable) + respectively. The emitter implementations will dispose/cancel this instance when the + downstream cancels the flow or after the event generator logic calls + onError(Throwable), onComplete() or when tryOnError(Throwable) succeeds. +

    + Only one Disposable or Cancellable object can be associated with the emitter at + a time. Calling either set method will dispose/cancel any previous object. If there + is a need for handling multiple resources, one can create a CompositeDisposable + and associate that with the emitter instead. +

    + The Cancellable is logically equivalent to Disposable but allows using cleanup logic that can + throw a checked exception (such as many close() methods on Java IO components). Since + the release of resources happens after the terminal events have been delivered or the sequence gets + cancelled, exceptions throw within Cancellable are routed to the global error handler via + RxJavaPlugins.onError(Throwable).

    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        onComplete

        +
        void onComplete()
        +
        Signal the completion.
        +
        • +
      + + + +
        +
      • +

        onError

        +
        void onError(@NonNull
+             @NonNull Throwable t)
        +
        Signal an exception.
        +
        +
        Parameters:
        +
        t - the exception, not null
        +
        +
        • +
      + + + + + + + +
        +
      • +

        setCancellable

        +
        void setCancellable(@Nullable
+                    @Nullable Cancellable c)
        +
        Sets a Cancellable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled.
        +
        +
        Parameters:
        +
        c - the cancellable resource, null is allowed
        +
        +
        • +
      + + + +
        +
      • +

        isDisposed

        +
        boolean isDisposed()
        +
        Returns true if the downstream disposed the sequence or the + emitter was terminated via onError(Throwable), + onComplete() or a successful tryOnError(Throwable). +

        This method is thread-safe.

        +
        +
        Returns:
        +
        true if the downstream disposed the sequence or the emitter was terminated
        +
        +
        • +
      + + + +
        +
      • +

        tryOnError

        +
        boolean tryOnError(@NonNull
+                   @NonNull Throwable t)
        +
        Attempts to emit the specified Throwable error if the downstream + hasn't cancelled the sequence or is otherwise terminated, returning false + if the emission is not allowed to happen due to lifecycle restrictions. +

        + Unlike onError(Throwable), the RxjavaPlugins.onError + is not called if the error could not be delivered. +

        History: 2.1.1 - experimental

        +
        +
        Parameters:
        +
        t - the throwable error to signal if possible
        +
        Returns:
        +
        true if successful, false if the downstream is not able to accept further + events
        +
        Since:
        +
        2.2
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableObserver.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableObserver.html new file mode 100644 index 0000000000..ed1d1e2bbf --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableObserver.html @@ -0,0 +1,301 @@ + + + + + +CompletableObserver (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface CompletableObserver

+
+
+
+
    +
  • +
    +
    All Known Implementing Classes:
    +
    CompletableSubject, DisposableCompletableObserver, ResourceCompletableObserver, TestObserver
    +
    +
    +
    +
    public interface CompletableObserver
    +
    Provides a mechanism for receiving push-based notification of a valueless completion or an error. +

    + When a CompletableObserver is subscribed to a CompletableSource through the CompletableSource.subscribe(CompletableObserver) method, + the CompletableSource calls onSubscribe(Disposable) with a Disposable that allows + disposing the sequence at any time. A well-behaved + CompletableSource will call a CompletableObserver's onError(Throwable) + or onComplete() method exactly once as they are considered mutually exclusive terminal signals. +

    + Calling the CompletableObserver's method must happen in a serialized fashion, that is, they must not + be invoked concurrently by multiple threads in an overlapping fashion and the invocation pattern must + adhere to the following protocol: + 

        onSubscribe (onError | onComplete)?
    +

    + Subscribing a CompletableObserver to multiple CompletableSources is not recommended. If such reuse + happens, it is the duty of the CompletableObserver implementation to be ready to receive multiple calls to + its methods and ensure proper concurrent behavior of its business logic. +

    + Calling onSubscribe(Disposable) or onError(Throwable) with a + null argument is forbidden. +

    + The implementations of the onXXX methods should avoid throwing runtime exceptions other than the following cases: +

      +
    • If the argument is null, the methods can throw a NullPointerException. + Note though that RxJava prevents nulls to enter into the flow and thus there is generally no + need to check for nulls in flows assembled from standard sources and intermediate operators. +
      • +
    • If there is a fatal error (such as VirtualMachineError).
      • +
    +
    +
    Since:
    +
    2.0
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        onSubscribe

        +
        void onSubscribe(@NonNull
+                 @NonNull Disposable d)
        +
        Called once by the Completable to set a Disposable on this instance which + then can be used to cancel the subscription at any time.
        +
        +
        Parameters:
        +
        d - the Disposable instance to call dispose on for cancellation, not null
        +
        +
        • +
      + + + +
        +
      • +

        onComplete

        +
        void onComplete()
        +
        Called once the deferred computation completes normally.
        +
        • +
      + + + +
        +
      • +

        onError

        +
        void onError(@NonNull
+             @NonNull Throwable e)
        +
        Called once if the deferred computation 'throws' an exception.
        +
        +
        Parameters:
        +
        e - the exception, not null.
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableOnSubscribe.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableOnSubscribe.html new file mode 100644 index 0000000000..afe90c2c35 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableOnSubscribe.html @@ -0,0 +1,237 @@ + + + + + +CompletableOnSubscribe (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface CompletableOnSubscribe

+
+
+
+
    +
  • +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface CompletableOnSubscribe
    +
    A functional interface that has a subscribe() method that receives + a CompletableEmitter instance that allows pushing + an event in a cancellation-safe manner.
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableOperator.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableOperator.html new file mode 100644 index 0000000000..80cc67a874 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableOperator.html @@ -0,0 +1,238 @@ + + + + + +CompletableOperator (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface CompletableOperator

+
+
+
+
    +
  • +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface CompletableOperator
    +
    Interface to map/wrap a downstream observer to an upstream observer.
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableSource.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableSource.html new file mode 100644 index 0000000000..a912f7f8dc --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableSource.html @@ -0,0 +1,243 @@ + + + + + +CompletableSource (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface CompletableSource

+
+
+
+
    +
  • +
    +
    All Known Implementing Classes:
    +
    Completable, CompletableSubject
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface CompletableSource
    +
    Represents a basic Completable source base interface, + consumable via an CompletableObserver.
    +
    +
    Since:
    +
    2.0
    +
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableTransformer.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableTransformer.html new file mode 100644 index 0000000000..d6b5e81b98 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/CompletableTransformer.html @@ -0,0 +1,236 @@ + + + + + +CompletableTransformer (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface CompletableTransformer

+
+
+
+
    +
  • +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface CompletableTransformer
    +
    Convenience interface and callback used by the compose operator to turn a Completable into another + Completable fluently.
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Emitter.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Emitter.html new file mode 100644 index 0000000000..37cf087e18 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Emitter.html @@ -0,0 +1,280 @@ + + + + + +Emitter (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface Emitter<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type emitted
    +
    +
    +
    All Known Subinterfaces:
    +
    FlowableEmitter<T>, ObservableEmitter<T>
    +
    +
    +
    +
    public interface Emitter<T>
    +
    Base interface for emitting signals in a push-fashion in various generator-like source + operators (create, generate). +

    + Note that the onNext(T), onError(java.lang.Throwable) and + onComplete() methods provided to the function via the Emitter instance should be called synchronously, + never concurrently. Calling them from multiple threads is not supported and leads to an + undefined behavior.

    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        onNext

        +
        void onNext(@NonNull
+            T value)
        +
        Signal a normal value.
        +
        +
        Parameters:
        +
        value - the value to signal, not null
        +
        +
        • +
      + + + + + + + +
        +
      • +

        onComplete

        +
        void onComplete()
        +
        Signal a completion.
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Flowable.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Flowable.html new file mode 100644 index 0000000000..444c0d6afe --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Flowable.html @@ -0,0 +1,28606 @@ + + + + + +Flowable (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Class Flowable<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the type of the items emitted by the Flowable
    +
    +
    +
    All Implemented Interfaces:
    +
    Publisher<T>
    +
    +
    +
    Direct Known Subclasses:
    +
    ConnectableFlowable, FlowableProcessor, GroupedFlowable
    +
    +
    +
    +
    public abstract class Flowable<T>
+extends Object
+implements Publisher<T>
    +
    The Flowable class that implements the Reactive Streams Publisher + Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows. +

    + Reactive Streams operates with Publishers which Flowable extends. Many operators + therefore accept general Publishers directly and allow direct interoperation with other + Reactive Streams implementations. +

    + The Flowable hosts the default buffer size of 128 elements for operators, accessible via bufferSize(), + that can be overridden globally via the system parameter rx3.buffer-size. Most operators, however, have + overloads that allow setting their internal buffer size explicitly. +

    + The documentation for this class makes use of marble diagrams. The following legend explains these diagrams: +

    + +

    + The Flowable follows the protocol + 

    
+      onSubscribe onNext* (onError | onComplete)?
+
    + where the stream can be disposed through the Subscription instance provided to consumers through + Subscriber.onSubscribe(Subscription). + Unlike the Observable.subscribe() of version 1.x, subscribe(Subscriber) does not allow external cancellation + of a subscription and the Subscriber instance is expected to expose such capability if needed. +

    + Flowables support backpressure and require Subscribers to signal demand via Subscription.request(long). +

    + Example: + 

    
+ Disposable d = Flowable.just("Hello world!")
+     .delay(1, TimeUnit.SECONDS)
+     .subscribeWith(new DisposableSubscriber<String>() {
+         @Override public void onStart() {
+             System.out.println("Start!");
+             request(1);
+         }
+         @Override public void onNext(String t) {
+             System.out.println(t);
+             request(1);
+         }
+         @Override public void onError(Throwable t) {
+             t.printStackTrace();
+         }
+         @Override public void onComplete() {
+             System.out.println("Done!");
+         }
+     });
+
+ Thread.sleep(500);
+ // the sequence can now be cancelled via dispose()
+ d.dispose();
+
    +

    + The Reactive Streams specification is relatively strict when defining interactions between Publishers and Subscribers, so much so + that there is a significant performance penalty due certain timing requirements and the need to prepare for invalid + request amounts via Subscription.request(long). + Therefore, RxJava has introduced the FlowableSubscriber interface that indicates the consumer can be driven with relaxed rules. + All RxJava operators are implemented with these relaxed rules in mind. + If the subscribing Subscriber does not implement this interface, for example, due to it being from another Reactive Streams compliant + library, the Flowable will automatically apply a compliance wrapper around it. +

    + Flowable is an abstract class, but it is not advised to implement sources and custom operators by extending the class directly due + to the large amounts of Reactive Streams + rules to be followed to the letter. See the wiki for + some guidance if such custom implementations are necessary. +

    + The recommended way of creating custom Flowables is by using the create(FlowableOnSubscribe, BackpressureStrategy) factory method: + 

    
+ Flowable<String> source = Flowable.create(new FlowableOnSubscribe<String>() {
+     @Override
+     public void subscribe(FlowableEmitter<String> emitter) throws Exception {
+
+         // signal an item
+         emitter.onNext("Hello");
+
+         // could be some blocking operation
+         Thread.sleep(1000);
+
+         // the consumer might have cancelled the flow
+         if (emitter.isCancelled()) {
+             return;
+         }
+
+         emitter.onNext("World");
+
+         Thread.sleep(1000);
+
+         // the end-of-sequence has to be signaled, otherwise the
+         // consumers may never finish
+         emitter.onComplete();
+     }
+ }, BackpressureStrategy.BUFFER);
+
+ System.out.println("Subscribe!");
+
+ source.subscribe(System.out::println);
+
+ System.out.println("Done!");
+
    +

    + RxJava reactive sources, such as Flowable, are generally synchronous and sequential in nature. In the ReactiveX design, the location (thread) + where operators run is orthogonal to when the operators can work with data. This means that asynchrony and parallelism + has to be explicitly expressed via operators such as subscribeOn(Scheduler), observeOn(Scheduler) and parallel(). In general, + operators featuring a Scheduler parameter are introducing this type of asynchrony into the flow. +

    + For more information see the ReactiveX documentation.

    +
    +
    See Also:
    +
    Observable, +ParallelFlowable, +DisposableSubscriber
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Flowable

        +
        public Flowable()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        amb

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> amb(@NonNull Iterable<? extends Publisher<? extends T>> sources)
        +
        Mirrors the one Publisher in an Iterable of several Publishers that first either emits an item or sends + a termination notification. +

        + +

        + When one of the Publishers signal an item or terminates first, all subscriptions to the other + Publishers are canceled. +

        +
        Backpressure:
        +
        The operator itself doesn't interfere with backpressure which is determined by the winning + Publisher's backpressure behavior.
        +
        Scheduler:
        +
        amb does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        + If any of the losing Publishers signals an error, the error is routed to the global + error handler via RxJavaPlugins.onError(Throwable). +
        +
        +
        +
        Type Parameters:
        +
        T - the common element type
        +
        Parameters:
        +
        sources - an Iterable of Publishers sources competing to react first. A subscription to each Publisher will + occur in the same order as in this Iterable.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Amb
        +
        +
        • +
      + + + +
        +
      • +

        ambArray

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+public static <T> @NonNull Flowable<T> ambArray(@NonNull Publisher<? extends T>... sources)
        +
        Mirrors the one Publisher in an array of several Publishers that first either emits an item or sends + a termination notification. +

        + +

        + When one of the Publishers signal an item or terminates first, all subscriptions to the other + Publishers are canceled. +

        +
        Backpressure:
        +
        The operator itself doesn't interfere with backpressure which is determined by the winning + Publisher's backpressure behavior.
        +
        Scheduler:
        +
        ambArray does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        + If any of the losing Publishers signals an error, the error is routed to the global + error handler via RxJavaPlugins.onError(Throwable). +
        +
        +
        +
        Type Parameters:
        +
        T - the common element type
        +
        Parameters:
        +
        sources - an array of Publisher sources competing to react first. A subscription to each Publisher will + occur in the same order as in this array.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Amb
        +
        +
        • +
      + + + +
        +
      • +

        bufferSize

        +
        @CheckReturnValue
+public static int bufferSize()
        +
        Returns the default internal buffer size used by most async operators. +

        The value can be overridden via system parameter rx3.buffer-size + before the Flowable class is loaded.

        +
        +
        Returns:
        +
        the default internal buffer size.
        +
        +
        • +
      + + + +
        +
      • +

        combineLatestArray

        +
        @SchedulerSupport(value="none")
+ @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @NonNull
+public static <T,R> @NonNull Flowable<R> combineLatestArray(@NonNull Publisher<? extends T>[] sources,
+        @NonNull Function<? super Object[],? extends R> combiner)
        +
        Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided array of source Publishers is empty, the resulting sequence completes immediately without emitting + any items and without any calls to the combiner function. + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatestArray does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the collection of source Publishers
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatestArray

        +
        @SchedulerSupport(value="none")
+ @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+public static <T,R> @NonNull Flowable<R> combineLatestArray(@NonNull Publisher<? extends T>[] sources,
+        @NonNull Function<? super Object[],? extends R> combiner,
+        int bufferSize)
        +
        Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided array of source Publishers is empty, the resulting sequence completes immediately without emitting + any items and without any calls to the combiner function. + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatestArray does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the collection of source Publishers
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        bufferSize - the internal buffer size and prefetch amount applied to every source Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @SchedulerSupport(value="none")
+ @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @NonNull
+public static <T,R> @NonNull Flowable<R> combineLatest(@NonNull Iterable<? extends Publisher<? extends T>> sources,
+        @NonNull Function<? super Object[],? extends R> combiner)
        +
        Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided iterable of source Publishers is empty, the resulting sequence completes immediately without emitting + any items and without any calls to the combiner function. + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the collection of source Publishers
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @SchedulerSupport(value="none")
+ @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+public static <T,R> @NonNull Flowable<R> combineLatest(@NonNull Iterable<? extends Publisher<? extends T>> sources,
+        @NonNull Function<? super Object[],? extends R> combiner,
+        int bufferSize)
        +
        Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided iterable of source Publishers is empty, the resulting sequence completes immediately without emitting any items and + without any calls to the combiner function. + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the collection of source Publishers
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        bufferSize - the internal buffer size and prefetch amount applied to every source Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatestArrayDelayError

        +
        @SchedulerSupport(value="none")
+ @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @NonNull
+public static <T,R> @NonNull Flowable<R> combineLatestArrayDelayError(@NonNull Publisher<? extends T>[] sources,
+        @NonNull Function<? super Object[],? extends R> combiner)
        +
        Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided array of source Publishers is empty, the resulting sequence completes immediately without emitting + any items and without any calls to the combiner function. + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatestArrayDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the collection of source Publishers
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatestArrayDelayError

        +
        @SchedulerSupport(value="none")
+ @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+public static <T,R> @NonNull Flowable<R> combineLatestArrayDelayError(@NonNull Publisher<? extends T>[] sources,
+        @NonNull Function<? super Object[],? extends R> combiner,
+        int bufferSize)
        +
        Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function and delays any error from the sources until + all source Publishers terminate. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided array of source Publishers is empty, the resulting sequence completes immediately without emitting + any items and without any calls to the combiner function. + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatestArrayDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the collection of source Publishers
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        bufferSize - the internal buffer size and prefetch amount applied to every source Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatestDelayError

        +
        @SchedulerSupport(value="none")
+ @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @NonNull
+public static <T,R> @NonNull Flowable<R> combineLatestDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources,
+        @NonNull Function<? super Object[],? extends R> combiner)
        +
        Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function and delays any error from the sources until + all source Publishers terminate. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided iterable of source Publishers is empty, the resulting sequence completes immediately without emitting + any items and without any calls to the combiner function. + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatestDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the collection of source Publishers
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatestDelayError

        +
        @SchedulerSupport(value="none")
+ @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @NonNull
+public static <T,R> @NonNull Flowable<R> combineLatestDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources,
+        @NonNull Function<? super Object[],? extends R> combiner,
+        int bufferSize)
        +
        Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of + the source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function and delays any error from the sources until + all source Publishers terminate. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided iterable of source Publishers is empty, the resulting sequence completes immediately without emitting + any items and without any calls to the combiner function. + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatestDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the collection of source Publishers
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        bufferSize - the internal buffer size and prefetch amount applied to every source Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T1,T2,R> @NonNull Flowable<R> combineLatest(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull BiFunction<? super T1,? super T2,? extends R> combiner)
        +
        Combines two source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from either of the source Publishers, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - the second source Publisher
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2 or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,R> @NonNull Flowable<R> combineLatest(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull Publisher<? extends T3> source3,
+        @NonNull Function3<? super T1,? super T2,? super T3,? extends R> combiner)
        +
        Combines three source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        T3 - the element type of the third source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - the second source Publisher
        +
        source3 - the third source Publisher
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3 or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,R> @NonNull Flowable<R> combineLatest(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull Publisher<? extends T3> source3,
+        @NonNull Publisher<? extends T4> source4,
+        @NonNull Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner)
        +
        Combines four source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        T3 - the element type of the third source
        +
        T4 - the element type of the fourth source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - the second source Publisher
        +
        source3 - the third source Publisher
        +
        source4 - the fourth source Publisher
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4 or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,R> @NonNull Flowable<R> combineLatest(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull Publisher<? extends T3> source3,
+        @NonNull Publisher<? extends T4> source4,
+        @NonNull Publisher<? extends T5> source5,
+        @NonNull Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> combiner)
        +
        Combines five source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        T3 - the element type of the third source
        +
        T4 - the element type of the fourth source
        +
        T5 - the element type of the fifth source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - the second source Publisher
        +
        source3 - the third source Publisher
        +
        source4 - the fourth source Publisher
        +
        source5 - the fifth source Publisher
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5 or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,R> @NonNull Flowable<R> combineLatest(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull Publisher<? extends T3> source3,
+        @NonNull Publisher<? extends T4> source4,
+        @NonNull Publisher<? extends T5> source5,
+        @NonNull Publisher<? extends T6> source6,
+        @NonNull Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> combiner)
        +
        Combines six source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        T3 - the element type of the third source
        +
        T4 - the element type of the fourth source
        +
        T5 - the element type of the fifth source
        +
        T6 - the element type of the sixth source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - the second source Publisher
        +
        source3 - the third source Publisher
        +
        source4 - the fourth source Publisher
        +
        source5 - the fifth source Publisher
        +
        source6 - the sixth source Publisher
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6 or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,T7,R> @NonNull Flowable<R> combineLatest(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull Publisher<? extends T3> source3,
+        @NonNull Publisher<? extends T4> source4,
+        @NonNull Publisher<? extends T5> source5,
+        @NonNull Publisher<? extends T6> source6,
+        @NonNull Publisher<? extends T7> source7,
+        @NonNull Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> combiner)
        +
        Combines seven source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        T3 - the element type of the third source
        +
        T4 - the element type of the fourth source
        +
        T5 - the element type of the fifth source
        +
        T6 - the element type of the sixth source
        +
        T7 - the element type of the seventh source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - the second source Publisher
        +
        source3 - the third source Publisher
        +
        source4 - the fourth source Publisher
        +
        source5 - the fifth source Publisher
        +
        source6 - the sixth source Publisher
        +
        source7 - the seventh source Publisher
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6, + source7 or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,T7,T8,R> @NonNull Flowable<R> combineLatest(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull Publisher<? extends T3> source3,
+        @NonNull Publisher<? extends T4> source4,
+        @NonNull Publisher<? extends T5> source5,
+        @NonNull Publisher<? extends T6> source6,
+        @NonNull Publisher<? extends T7> source7,
+        @NonNull Publisher<? extends T8> source8,
+        @NonNull Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> combiner)
        +
        Combines eight source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        T3 - the element type of the third source
        +
        T4 - the element type of the fourth source
        +
        T5 - the element type of the fifth source
        +
        T6 - the element type of the sixth source
        +
        T7 - the element type of the seventh source
        +
        T8 - the element type of the eighth source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - the second source Publisher
        +
        source3 - the third source Publisher
        +
        source4 - the fourth source Publisher
        +
        source5 - the fifth source Publisher
        +
        source6 - the sixth source Publisher
        +
        source7 - the seventh source Publisher
        +
        source8 - the eighth source Publisher
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6, + source7, source8 or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> @NonNull Flowable<R> combineLatest(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull Publisher<? extends T3> source3,
+        @NonNull Publisher<? extends T4> source4,
+        @NonNull Publisher<? extends T5> source5,
+        @NonNull Publisher<? extends T6> source6,
+        @NonNull Publisher<? extends T7> source7,
+        @NonNull Publisher<? extends T8> source8,
+        @NonNull Publisher<? extends T9> source9,
+        @NonNull Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> combiner)
        +
        Combines nine source Publishers by emitting an item that aggregates the latest values of each of the + source Publishers each time an item is received from any of the source Publishers, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated until that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Backpressure:
        +
        The returned Publisher honors backpressure from downstream. The source Publishers + are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal + MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        T3 - the element type of the third source
        +
        T4 - the element type of the fourth source
        +
        T5 - the element type of the fifth source
        +
        T6 - the element type of the sixth source
        +
        T7 - the element type of the seventh source
        +
        T8 - the element type of the eighth source
        +
        T9 - the element type of the ninth source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - the second source Publisher
        +
        source3 - the third source Publisher
        +
        source4 - the fourth source Publisher
        +
        source5 - the fifth source Publisher
        +
        source6 - the sixth source Publisher
        +
        source7 - the seventh source Publisher
        +
        source8 - the eighth source Publisher
        +
        source9 - the ninth source Publisher
        +
        combiner - the aggregation function used to combine the items emitted by the source Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6, + source7, source8, source9 + or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        concatArray

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+ @NonNull
+public static <T> @NonNull Flowable<T> concatArray(@NonNull Publisher<? extends T>... sources)
        +
        Concatenates a variable number of Publisher sources. +

        + Note: named this way because of overload conflict with concat(Publisher<Publisher<T>>). +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The Publisher + sources are expected to honor backpressure as well. + If any of the source Publishers violate this, it may throw an + IllegalStateException when that source Publisher completes.
        +
        Scheduler:
        +
        concatArray does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base value type
        +
        Parameters:
        +
        sources - the array of source Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        +
        • +
      + + + +
        +
      • +

        concatArrayDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+ @NonNull
+public static <T> @NonNull Flowable<T> concatArrayDelayError(@NonNull Publisher<? extends T>... sources)
        +
        Concatenates a variable number of Publisher sources and delays errors from any of them + till all terminate. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The Publisher + sources are expected to honor backpressure as well. + If any of the source Publishers violate this, it may throw an + IllegalStateException when that source Publisher completes.
        +
        Scheduler:
        +
        concatArrayDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base value type
        +
        Parameters:
        +
        sources - the array of source Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        +
        • +
      + + + +
        +
      • +

        concatArrayEager

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+ @NonNull
+public static <T> @NonNull Flowable<T> concatArrayEager(@NonNull Publisher<? extends T>... sources)
        +
        Concatenates an array of Publishers eagerly into a single stream of values. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + source Publishers. The operator buffers the values emitted by these Publishers and then drains them + in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The Publisher + sources are expected to honor backpressure as well. + If any of the source Publishers violate this, the operator will signal a + MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - an array of Publishers that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatArrayEager

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+public static <T> @NonNull Flowable<T> concatArrayEager(int maxConcurrency,
+        int prefetch,
+        @NonNull Publisher<? extends T>... sources)
        +
        Concatenates an array of Publishers eagerly into a single stream of values. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + source Publishers. The operator buffers the values emitted by these Publishers and then drains them + in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The Publisher + sources are expected to honor backpressure as well. + If any of the source Publishers violate this, the operator will signal a + MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - an array of Publishers that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrent subscriptions at a time, Integer.MAX_VALUE + is interpreted as an indication to subscribe to all sources at once
        +
        prefetch - the number of elements to prefetch from each Publisher source
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or prefetch is non-positive
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatArrayEagerDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=FULL)
+ @SafeVarargs
+ @NonNull
+public static <T> @NonNull Flowable<T> concatArrayEagerDelayError(@NonNull Publisher<? extends T>... sources)
        +
        Concatenates an array of Publishers eagerly into a single stream of values + and delaying any errors until all sources terminate. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + source Publishers. The operator buffers the values emitted by these Publishers + and then drains them in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The Publisher + sources are expected to honor backpressure as well. + If any of the source Publishers violate this, the operator will signal a + MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - an array of Publishers that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        2.2.1 - experimental
        +
        +
        • +
      + + + +
        +
      • +

        concatArrayEagerDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=FULL)
+ @SafeVarargs
+ @NonNull
+public static <T> @NonNull Flowable<T> concatArrayEagerDelayError(int maxConcurrency,
+        int prefetch,
+        @NonNull Publisher<? extends T>... sources)
        +
        Concatenates an array of Publishers eagerly into a single stream of values + and delaying any errors until all sources terminate. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + source Publishers. The operator buffers the values emitted by these Publishers + and then drains them in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The Publisher + sources are expected to honor backpressure as well. + If any of the source Publishers violate this, the operator will signal a + MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - an array of Publishers that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrent subscriptions at a time, Integer.MAX_VALUE + is interpreted as indication to subscribe to all sources at once
        +
        prefetch - the number of elements to prefetch from each Publisher source
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or prefetch is non-positive
        +
        Since:
        +
        2.2.1 - experimental
        +
        +
        • +
      + + + +
        +
      • +

        concatDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> concatDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources)
        +
        Concatenates the Iterable sequence of Publishers into a single sequence by subscribing to each Publisher, + one after the other, one at a time and delays any errors till the all inner Publishers terminate. + +
        +
        Backpressure:
        +
        The operator honors backpressure from downstream. Both the outer and inner Publisher + sources are expected to honor backpressure as well. If the outer violates this, a + MissingBackpressureException is signaled. If any of the inner Publishers violates + this, it may throw an IllegalStateException when an inner Publisher completes.
        +
        Scheduler:
        +
        concatDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable sequence of Publishers
        +
        Returns:
        +
        the new Flowable with the concatenating behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        +
        • +
      + + + +
        +
      • +

        concatDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources)
        +
        Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, + one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate. + +
        +
        Backpressure:
        +
        concatDelayError fully supports backpressure.
        +
        Scheduler:
        +
        concatDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Publisher sequence of Publishers
        +
        Returns:
        +
        the new Flowable with the concatenating behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        +
        • +
      + + + +
        +
      • +

        concatDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources,
+        int prefetch,
+        boolean tillTheEnd)
        +
        Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, + one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate. + +
        +
        Backpressure:
        +
        concatDelayError fully supports backpressure.
        +
        Scheduler:
        +
        concatDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Publisher sequence of Publishers
        +
        prefetch - the number of elements to prefetch from the outer Publisher
        +
        tillTheEnd - if true, exceptions from the outer and all inner Publishers are delayed to the end + if false, exception from the outer Publisher is delayed till the current inner Publisher terminates
        +
        Returns:
        +
        the new Flowable with the concatenating behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if prefetch is null
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatEager(@NonNull Iterable<? extends Publisher<? extends T>> sources)
        +
        Concatenates a sequence of Publishers eagerly into a single stream of values. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + source Publishers. The operator buffers the values emitted by these Publishers and then drains them + in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and the inner Publishers are + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of Publishers that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> concatEager(@NonNull Iterable<? extends Publisher<? extends T>> sources,
+        int maxConcurrency,
+        int prefetch)
        +
        Concatenates a sequence of Publishers eagerly into a single stream of values and + runs a limited number of inner sequences at once. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + source Publishers. The operator buffers the values emitted by these Publishers and then drains them + in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and both the outer and inner Publishers are + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of Publishers that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrently running inner Publishers; Integer.MAX_VALUE + is interpreted as all inner Publishers can be active at the same time
        +
        prefetch - the number of elements to prefetch from each inner Publisher source
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or prefetch is non-positive
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatEager(@NonNull Publisher<? extends Publisher<? extends T>> sources)
        +
        Concatenates a Publisher sequence of Publishers eagerly into a single stream of values. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source Publishers as they are observed. The operator buffers the values emitted by these + Publishers and then drains them in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and both the outer and inner Publishers are + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of Publishers that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> concatEager(@NonNull Publisher<? extends Publisher<? extends T>> sources,
+        int maxConcurrency,
+        int prefetch)
        +
        Concatenates a Publisher sequence of Publishers eagerly into a single stream of values and + runs a limited number of inner sequences at once. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source Publishers as they are observed. The operator buffers the values emitted by these + Publishers and then drains them in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and both the outer and inner Publishers are + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of Publishers that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrently running inner Publishers; Integer.MAX_VALUE + is interpreted as all inner Publishers can be active at the same time
        +
        prefetch - the number of elements to prefetch from each inner Publisher source
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or prefetch is non-positive
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources)
        +
        Concatenates a sequence of Publishers eagerly into a single stream of values, + delaying errors until all the inner sequences terminate. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + source Publishers. The operator buffers the values emitted by these Publishers and then drains them + in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and the inner Publishers are + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of Publishers that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources,
+        int maxConcurrency,
+        int prefetch)
        +
        Concatenates a sequence of Publishers eagerly into a single stream of values, + delaying errors until all the inner sequences terminate and runs a limited number + of inner sequences at once. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + source Publishers. The operator buffers the values emitted by these Publishers and then drains them + in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and both the outer and inner Publishers are + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of Publishers that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrently running inner Publishers; Integer.MAX_VALUE + is interpreted as all inner Publishers can be active at the same time
        +
        prefetch - the number of elements to prefetch from each inner Publisher source
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or prefetch is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources)
        +
        Concatenates a Publisher sequence of Publishers eagerly into a single stream of values, + delaying errors until all the inner and the outer sequences terminate. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source Publishers as they are observed. The operator buffers the values emitted by these + Publishers and then drains them in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and both the outer and inner Publishers are + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of Publishers that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources,
+        int maxConcurrency,
+        int prefetch)
        +
        Concatenates a Publisher sequence of Publishers eagerly into a single stream of values, + delaying errors until all the inner and outer sequences terminate and runs a limited number of inner + sequences at once. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source Publishers as they are observed. The operator buffers the values emitted by these + Publishers and then drains them in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and both the outer and inner Publishers are + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of Publishers that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrently running inner Publishers; Integer.MAX_VALUE + is interpreted as all inner Publishers can be active at the same time
        +
        prefetch - the number of elements to prefetch from each inner Publisher source
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or prefetch is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> create(@NonNull FlowableOnSubscribe<T> source,
+        @NonNull BackpressureStrategy mode)
        +
        Provides an API (via a cold Flowable) that bridges the reactive world with the callback-style, + generally non-backpressured world. +

        + Example: + 

        
+ Flowable.<Event>create(emitter -> {
+     Callback listener = new Callback() {
+         @Override
+         public void onEvent(Event e) {
+             emitter.onNext(e);
+             if (e.isLast()) {
+                 emitter.onComplete();
+             }
+         }
+
+         @Override
+         public void onFailure(Exception e) {
+             emitter.onError(e);
+         }
+     };
+
+     AutoCloseable c = api.someMethod(listener);
+
+     emitter.setCancellable(c::close);
+
+ }, BackpressureStrategy.BUFFER);
+
        +

        + Whenever a Subscriber subscribes to the returned Flowable, the provided + FlowableOnSubscribe callback is invoked with a fresh instance of a FlowableEmitter + that will interact only with that specific Subscriber. If this Subscriber + cancels the flow (making FlowableEmitter.isCancelled() return true), + other observers subscribed to the same returned Flowable are not affected. +

        + You should call the Emitter.onNext(Object), Emitter.onError(Throwable) + and Emitter.onComplete() methods in a serialized fashion. The + rest of its methods are thread-safe. +

        +
        Backpressure:
        +
        The backpressure behavior is determined by the mode parameter.
        +
        Scheduler:
        +
        create does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type
        +
        Parameters:
        +
        source - the emitter that is called when a Subscriber subscribes to the returned Flowable
        +
        mode - the backpressure mode to apply if the downstream Subscriber doesn't request (fast) enough
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source or mode is null
        +
        See Also:
        +
        FlowableOnSubscribe, +BackpressureStrategy, +Cancellable
        +
        +
        • +
      + + + +
        +
      • +

        defer

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> defer(@NonNull Supplier<? extends Publisher<? extends T>> supplier)
        +
        Returns a Flowable that calls a Publisher factory to create a Publisher for each new Subscriber + that subscribes. That is, for each subscriber, the actual Publisher that subscriber observes is + determined by the factory function. +

        + +

        + The defer Subscriber allows you to defer or delay emitting items from a Publisher until such time as a + Subscriber subscribes to the Publisher. This allows a Subscriber to easily obtain updates or a + refreshed version of the sequence. +

        +
        Backpressure:
        +
        The operator itself doesn't interfere with backpressure which is determined by the Publisher + returned by the supplier.
        +
        Scheduler:
        +
        defer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the type of the items emitted by the Publisher
        +
        Parameters:
        +
        supplier - the Publisher factory function to invoke for each Subscriber that subscribes to the + resulting Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if supplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: Defer
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        fromCallable

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> fromCallable(@NonNull Callable<? extends T> callable)
        +
        Returns a Flowable that, when a Subscriber subscribes to it, invokes a function you specify and then + emits the value returned from that function. +

        + +

        + This allows you to defer the execution of the function you specify until a Subscriber subscribes to the + Publisher. That is to say, it makes the function "lazy." +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        fromCallable does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the Callable throws an exception, the respective Throwable is + delivered to the downstream via Subscriber.onError(Throwable), + except when the downstream has canceled this Flowable source. + In this latter case, the Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) as an UndeliverableException. +
        +
        +
        +
        Type Parameters:
        +
        T - the type of the item emitted by the Publisher
        +
        Parameters:
        +
        callable - a function, the execution of which should be deferred; fromCallable will invoke this + function only when a Subscriber subscribes to the Publisher that fromCallable returns
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if callable is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        defer(Supplier), +fromSupplier(Supplier)
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        fromMaybe

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=FULL)
+public static <T> @NonNull Flowable<T> fromMaybe(@NonNull MaybeSource<T> maybe)
        +
        Returns a Flowable instance that when subscribed to, subscribes to the MaybeSource instance and + emits onSuccess as a single item or forwards any onComplete or + onError signal. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        fromMaybe does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type of the MaybeSource element
        +
        Parameters:
        +
        maybe - the MaybeSource instance to subscribe to, not null
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if maybe is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        fromRunnable

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=PASS_THROUGH)
+public static <T> @NonNull Flowable<T> fromRunnable(@NonNull Runnable run)
        +
        Returns a Flowable instance that runs the given Runnable for each Subscriber and + emits either its unchecked exception or simply completes. +

        + +

        + If the code to be wrapped needs to throw a checked or more broader Throwable exception, that + exception has to be converted to an unchecked exception by the wrapped code itself. Alternatively, + use the fromAction(Action) method which allows the wrapped code to throw any Throwable + exception and will signal it to observers as-is. +

        +
        Backpressure:
        +
        This source doesn't produce any elements and effectively ignores downstream backpressure.
        +
        Scheduler:
        +
        fromRunnable does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the Runnable throws an exception, the respective Throwable is + delivered to the downstream via Subscriber.onError(Throwable), + except when the downstream has canceled the resulting Flowable source. + In this latter case, the Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) as an UndeliverableException. +
        +
        +
        +
        Type Parameters:
        +
        T - the target type
        +
        Parameters:
        +
        run - the Runnable to run for each Subscriber
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if run is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        fromAction(Action)
        +
        +
        • +
      + + + +
        +
      • +

        fromSingle

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=FULL)
+public static <T> @NonNull Flowable<T> fromSingle(@NonNull SingleSource<T> source)
        +
        Returns a Flowable instance that when subscribed to, subscribes to the SingleSource instance and + emits onSuccess as a single item or forwards the onError signal. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        fromSingle does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type of the SingleSource element
        +
        Parameters:
        +
        source - the SingleSource instance to subscribe to, not null
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        fromSupplier

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> fromSupplier(@NonNull Supplier<? extends T> supplier)
        +
        Returns a Flowable that, when a Subscriber subscribes to it, invokes a supplier function you specify and then + emits the value returned from that function. +

        + +

        + This allows you to defer the execution of the function you specify until a Subscriber subscribes to the + Publisher. That is to say, it makes the function "lazy." +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        fromSupplier does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the Supplier throws an exception, the respective Throwable is + delivered to the downstream via Subscriber.onError(Throwable), + except when the downstream has canceled this Flowable source. + In this latter case, the Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) as an UndeliverableException. +
        +
        +
        +
        Type Parameters:
        +
        T - the type of the item emitted by the Publisher
        +
        Parameters:
        +
        supplier - a function, the execution of which should be deferred; fromSupplier will invoke this + function only when a Subscriber subscribes to the Publisher that fromSupplier returns
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if supplier is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        defer(Supplier), +fromCallable(Callable)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        generate

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T,S> @NonNull Flowable<T> generate(@NonNull Supplier<S> initialState,
+        @NonNull BiConsumer<S,Emitter<T>> generator)
        +
        Returns a cold, synchronous, stateful and backpressure-aware generator of values. +

        + Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and + Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, + never concurrently and only while the function body is executing. Calling them from multiple threads + or outside the function call is not supported and leads to an undefined behavior. +

        +
        Backpressure:
        +
        The operator honors downstream backpressure.
        +
        Scheduler:
        +
        generate does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        S - the type of the per-Subscriber state
        +
        T - the generated value type
        +
        Parameters:
        +
        initialState - the Supplier to generate the initial state for each Subscriber
        +
        generator - the Consumer called with the current state whenever a particular downstream Subscriber has + requested a value. The callback then should call onNext, onError or + onComplete to signal a value or a terminal event. Signaling multiple onNext + in a call will make the operator signal IllegalStateException.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if initialState or generator is null
        +
        +
        • +
      + + + +
        +
      • +

        generate

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T,S> @NonNull Flowable<T> generate(@NonNull Supplier<S> initialState,
+        @NonNull BiConsumer<S,Emitter<T>> generator,
+        @NonNull Consumer<? super S> disposeState)
        +
        Returns a cold, synchronous, stateful and backpressure-aware generator of values. +

        + Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and + Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, + never concurrently and only while the function body is executing. Calling them from multiple threads + or outside the function call is not supported and leads to an undefined behavior. +

        +
        Backpressure:
        +
        The operator honors downstream backpressure.
        +
        Scheduler:
        +
        generate does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        S - the type of the per-Subscriber state
        +
        T - the generated value type
        +
        Parameters:
        +
        initialState - the Supplier to generate the initial state for each Subscriber
        +
        generator - the Consumer called with the current state whenever a particular downstream Subscriber has + requested a value. The callback then should call onNext, onError or + onComplete to signal a value or a terminal event. Signaling multiple onNext + in a call will make the operator signal IllegalStateException.
        +
        disposeState - the Consumer that is called with the current state when the generator + terminates the sequence or it gets canceled
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if initialState, generator or disposeState is null
        +
        +
        • +
      + + + +
        +
      • +

        generate

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T,S> @NonNull Flowable<T> generate(@NonNull Supplier<S> initialState,
+        @NonNull BiFunction<S,Emitter<T>,S> generator)
        +
        Returns a cold, synchronous, stateful and backpressure-aware generator of values. +

        + Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and + Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, + never concurrently and only while the function body is executing. Calling them from multiple threads + or outside the function call is not supported and leads to an undefined behavior. +

        +
        Backpressure:
        +
        The operator honors downstream backpressure.
        +
        Scheduler:
        +
        generate does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        S - the type of the per-Subscriber state
        +
        T - the generated value type
        +
        Parameters:
        +
        initialState - the Supplier to generate the initial state for each Subscriber
        +
        generator - the Function called with the current state whenever a particular downstream Subscriber has + requested a value. The callback then should call onNext, onError or + onComplete to signal a value or a terminal event and should return a (new) state for + the next invocation. Signaling multiple onNext + in a call will make the operator signal IllegalStateException.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if initialState or generator is null
        +
        +
        • +
      + + + +
        +
      • +

        generate

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T,S> @NonNull Flowable<T> generate(@NonNull Supplier<S> initialState,
+        @NonNull BiFunction<S,Emitter<T>,S> generator,
+        @NonNull Consumer<? super S> disposeState)
        +
        Returns a cold, synchronous, stateful and backpressure-aware generator of values. +

        + Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and + Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, + never concurrently and only while the function body is executing. Calling them from multiple threads + or outside the function call is not supported and leads to an undefined behavior. +

        +
        Backpressure:
        +
        The operator honors downstream backpressure.
        +
        Scheduler:
        +
        generate does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        S - the type of the per-Subscriber state
        +
        T - the generated value type
        +
        Parameters:
        +
        initialState - the Supplier to generate the initial state for each Subscriber
        +
        generator - the Function called with the current state whenever a particular downstream Subscriber has + requested a value. The callback then should call onNext, onError or + onComplete to signal a value or a terminal event and should return a (new) state for + the next invocation. Signaling multiple onNext + in a call will make the operator signal IllegalStateException.
        +
        disposeState - the Consumer that is called with the current state when the generator + terminates the sequence or it gets canceled
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if initialState, generator or disposeState is null
        +
        +
        • +
      + + + +
        +
      • +

        interval

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public static @NonNull Flowable<Long> interval(long initialDelay,
+        long period,
+        @NonNull TimeUnit unit)
        +
        Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers + after each period of time thereafter. +

        + +

        +
        Backpressure:
        +
        The operator generates values based on time and ignores downstream backpressure which + may lead to MissingBackpressureException at some point in the chain. + Downstream consumers should consider applying one of the onBackpressureXXX operators as well.
        +
        Scheduler:
        +
        interval operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        initialDelay - the initial delay time to wait before emitting the first value of 0L
        +
        period - the period of time between emissions of the subsequent numbers
        +
        unit - the time unit for both initialDelay and period
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        1.0.12
        +
        See Also:
        +
        ReactiveX operators documentation: Interval
        +
        +
        • +
      + + + +
        +
      • +

        interval

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+public static @NonNull Flowable<Long> interval(long initialDelay,
+        long period,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers + after each period of time thereafter, on a specified Scheduler. +

        + +

        +
        Backpressure:
        +
        The operator generates values based on time and ignores downstream backpressure which + may lead to MissingBackpressureException at some point in the chain. + Downstream consumers should consider applying one of the onBackpressureXXX operators as well.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        initialDelay - the initial delay time to wait before emitting the first value of 0L
        +
        period - the period of time between emissions of the subsequent numbers
        +
        unit - the time unit for both initialDelay and period
        +
        scheduler - the Scheduler on which the waiting happens and items are emitted
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        Since:
        +
        1.0.12
        +
        See Also:
        +
        ReactiveX operators documentation: Interval
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        intervalRange

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="io.reactivex:computation")
+public static @NonNull Flowable<Long> intervalRange(long start,
+        long count,
+        long initialDelay,
+        long period,
+        @NonNull TimeUnit unit)
        +
        Signals a range of long values, the first after some initial delay and the rest periodically after. +

        + The sequence completes immediately after the last value (start + count - 1) has been reached. +

        +
        Backpressure:
        +
        The operator signals a MissingBackpressureException if the downstream can't keep up.
        +
        Scheduler:
        +
        intervalRange by default operates on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        start - that start value of the range
        +
        count - the number of values to emit in total, if zero, the operator emits an onComplete after the initial delay.
        +
        initialDelay - the initial delay before signaling the first value (the start)
        +
        period - the period between subsequent values
        +
        unit - the unit of measure of the initialDelay and period amounts
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        IllegalArgumentException - if count is less than zero, or if start + count − 1 exceeds + Long.MAX_VALUE
        +
        See Also:
        +
        range(int, int)
        +
        +
        • +
      + + + +
        +
      • +

        intervalRange

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+public static @NonNull Flowable<Long> intervalRange(long start,
+        long count,
+        long initialDelay,
+        long period,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Signals a range of long values, the first after some initial delay and the rest periodically after. +

        + The sequence completes immediately after the last value (start + count - 1) has been reached. +

        +
        Backpressure:
        +
        The operator signals a MissingBackpressureException if the downstream can't keep up.
        +
        Scheduler:
        +
        you provide the Scheduler.
        +
        +
        +
        Parameters:
        +
        start - that start value of the range
        +
        count - the number of values to emit in total, if zero, the operator emits an onComplete after the initial delay.
        +
        initialDelay - the initial delay before signaling the first value (the start)
        +
        period - the period between subsequent values
        +
        unit - the unit of measure of the initialDelay and period amounts
        +
        scheduler - the target Scheduler where the values and terminal signals will be emitted
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if count is less than zero, or if start + count − 1 exceeds + Long.MAX_VALUE
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        just

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> just(T item1,
+        T item2,
+        T item3,
+        T item4,
+        T item5,
+        T item6)
        +
        Converts six items into a Publisher that emits those items. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
        +
        Scheduler:
        +
        just does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the type of these items
        +
        Parameters:
        +
        item1 - first item
        +
        item2 - second item
        +
        item3 - third item
        +
        item4 - fourth item
        +
        item5 - fifth item
        +
        item6 - sixth item
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if item1, item2, item3, + item4, item5 or item6 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Just
        +
        +
        • +
      + + + + + +
        +
      • +

        just

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> just(T item1,
+        T item2,
+        T item3,
+        T item4,
+        T item5,
+        T item6,
+        T item7)
        +
        Converts seven items into a Publisher that emits those items. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
        +
        Scheduler:
        +
        just does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the type of these items
        +
        Parameters:
        +
        item1 - first item
        +
        item2 - second item
        +
        item3 - third item
        +
        item4 - fourth item
        +
        item5 - fifth item
        +
        item6 - sixth item
        +
        item7 - seventh item
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if item1, item2, item3, + item4, item5, item6 + or item7 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Just
        +
        +
        • +
      + + + + + +
        +
      • +

        just

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> just(T item1,
+        T item2,
+        T item3,
+        T item4,
+        T item5,
+        T item6,
+        T item7,
+        T item8)
        +
        Converts eight items into a Publisher that emits those items. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
        +
        Scheduler:
        +
        just does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the type of these items
        +
        Parameters:
        +
        item1 - first item
        +
        item2 - second item
        +
        item3 - third item
        +
        item4 - fourth item
        +
        item5 - fifth item
        +
        item6 - sixth item
        +
        item7 - seventh item
        +
        item8 - eighth item
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if item1, item2, item3, + item4, item5, item6, + item7 or item8 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Just
        +
        +
        • +
      + + + + + +
        +
      • +

        just

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> just(T item1,
+        T item2,
+        T item3,
+        T item4,
+        T item5,
+        T item6,
+        T item7,
+        T item8,
+        T item9)
        +
        Converts nine items into a Publisher that emits those items. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
        +
        Scheduler:
        +
        just does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the type of these items
        +
        Parameters:
        +
        item1 - first item
        +
        item2 - second item
        +
        item3 - third item
        +
        item4 - fourth item
        +
        item5 - fifth item
        +
        item6 - sixth item
        +
        item7 - seventh item
        +
        item8 - eighth item
        +
        item9 - ninth item
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if item1, item2, item3, + item4, item5, item6, + item7, item8 or item9 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Just
        +
        +
        • +
      + + + + + +
        +
      • +

        just

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> just(T item1,
+        T item2,
+        T item3,
+        T item4,
+        T item5,
+        T item6,
+        T item7,
+        T item8,
+        T item9,
+        T item10)
        +
        Converts ten items into a Publisher that emits those items. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
        +
        Scheduler:
        +
        just does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the type of these items
        +
        Parameters:
        +
        item1 - first item
        +
        item2 - second item
        +
        item3 - third item
        +
        item4 - fourth item
        +
        item5 - fifth item
        +
        item6 - sixth item
        +
        item7 - seventh item
        +
        item8 - eighth item
        +
        item9 - ninth item
        +
        item10 - tenth item
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if item1, item2, item3, + item4, item5, item6, + item7, item8, item9, + or item10 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Just
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> merge(@NonNull Iterable<? extends Publisher<? extends T>> sources,
+        int maxConcurrency,
+        int bufferSize)
        +
        Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the + number of concurrent subscriptions to these Publishers. +

        + +

        + You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by + using the merge method. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The source Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source Publishers signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source Publishers are canceled. + If more than one Publisher signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been canceled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(Iterable, int, int) to merge sources and terminate only when all source Publishers + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable of Publishers
        +
        maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
        +
        bufferSize - the number of items to prefetch from each inner Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeDelayError(Iterable, int, int)
        +
        +
        • +
      + + + +
        +
      • +

        mergeArray

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+ @NonNull
+public static <T> @NonNull Flowable<T> mergeArray(int maxConcurrency,
+        int bufferSize,
+        @NonNull Publisher<? extends T>... sources)
        +
        Flattens an array of Publishers into one Publisher, without any transformation, while limiting the + number of concurrent subscriptions to these Publishers. +

        + +

        + You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by + using the merge method. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The source Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        mergeArray does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source Publishers signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source Publishers are canceled. + If more than one Publisher signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been canceled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeArrayDelayError(int, int, Publisher[]) to merge sources and terminate only when all source Publishers + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the array of Publishers
        +
        maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
        +
        bufferSize - the number of items to prefetch from each inner Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeArrayDelayError(int, int, Publisher...)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> merge(@NonNull Iterable<? extends Publisher<? extends T>> sources)
        +
        Flattens an Iterable of Publishers into one Publisher, without any transformation. +

        + +

        + You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by + using the merge method. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The source Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source Publishers signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source Publishers are canceled. + If more than one Publisher signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been canceled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(Iterable) to merge sources and terminate only when all source Publishers + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable of Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeDelayError(Iterable)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> merge(@NonNull Iterable<? extends Publisher<? extends T>> sources,
+        int maxConcurrency)
        +
        Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the + number of concurrent subscriptions to these Publishers. +

        + +

        + You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by + using the merge method. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The source Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source Publishers signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source Publishers are canceled. + If more than one Publisher signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been canceled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(Iterable, int) to merge sources and terminate only when all source Publishers + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable of Publishers
        +
        maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is less than or equal to 0
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeDelayError(Iterable, int)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> merge(@NonNull Publisher<? extends Publisher<? extends T>> sources)
        +
        Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by + thos Publishers , without any transformation. +

        + +

        + You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by + using the merge method. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The outer Publisher is consumed + in unbounded mode (i.e., no backpressure is applied to it). The inner Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source Publishers signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source Publishers are canceled. + If more than one Publisher signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been canceled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(Publisher) to merge sources and terminate only when all source Publishers + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - a Publisher that emits Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeDelayError(Publisher)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> merge(@NonNull Publisher<? extends Publisher<? extends T>> sources,
+        int maxConcurrency)
        +
        Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by + those Publishers, without any transformation, while limiting the maximum number of concurrent + subscriptions to these Publishers. +

        + +

        + You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by + using the merge method. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. Both the outer and inner Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source Publishers signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source Publishers are canceled. + If more than one Publisher signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been canceled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(Publisher, int) to merge sources and terminate only when all source Publishers + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - a Publisher that emits Publishers
        +
        maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is less than or equal to 0
        +
        Since:
        +
        1.1.0
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeDelayError(Publisher, int)
        +
        +
        • +
      + + + +
        +
      • +

        mergeArray

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+ @NonNull
+public static <T> @NonNull Flowable<T> mergeArray(@NonNull Publisher<? extends T>... sources)
        +
        Flattens an array of Publishers into one Publisher, without any transformation. +

        + +

        + You can combine items emitted by multiple Publishers so that they appear as a single Publisher, by + using the merge method. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The source Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        mergeArray does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source Publishers signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source Publishers are canceled. + If more than one Publisher signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been canceled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeArrayDelayError(Publisher...) to merge sources and terminate only when all source Publishers + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the array of Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeArrayDelayError(Publisher...)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> merge(@NonNull Publisher<? extends T> source1,
+        @NonNull Publisher<? extends T> source2)
        +
        Flattens two Publishers into a single Publisher, without any transformation. +

        + +

        + You can combine items emitted by multiple Publishers so that they appear as a single Publisher, by + using the merge method. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The source Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source Publishers signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source Publishers are canceled. + If more than one Publisher signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been canceled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(Publisher, Publisher) to merge sources and terminate only when all source Publishers + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        source1 - a Publisher to be merged
        +
        source2 - a Publisher to be merged
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1 or source2 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeDelayError(Publisher, Publisher)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> merge(@NonNull Publisher<? extends T> source1,
+        @NonNull Publisher<? extends T> source2,
+        @NonNull Publisher<? extends T> source3)
        +
        Flattens three Publishers into a single Publisher, without any transformation. +

        + +

        + You can combine items emitted by multiple Publishers so that they appear as a single Publisher, by + using the merge method. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The source Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source Publishers signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source Publishers are canceled. + If more than one Publisher signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been canceled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(Publisher, Publisher, Publisher) to merge sources and terminate only when all source Publishers + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        source1 - a Publisher to be merged
        +
        source2 - a Publisher to be merged
        +
        source3 - a Publisher to be merged
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2 or source3 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeDelayError(Publisher, Publisher, Publisher)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        mergeDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources)
        +
        Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all + successfully emitted items from each of the source Publishers without being interrupted by an error + notification from one of them. +

        + This behaves like merge(Publisher) except that if any of the merged Publishers notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged Publishers have finished emitting items. +

        + +

        + Even if multiple merged Publishers send onError notifications, mergeDelayError will only + invoke the onError method of its Subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. All inner Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable of Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources,
+        int maxConcurrency,
+        int bufferSize)
        +
        Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all + successfully emitted items from each of the source Publishers without being interrupted by an error + notification from one of them, while limiting the number of concurrent subscriptions to these Publishers. +

        + This behaves like merge(Publisher) except that if any of the merged Publishers notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged Publishers have finished emitting items. +

        + +

        + Even if multiple merged Publishers send onError notifications, mergeDelayError will only + invoke the onError method of its Subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. All inner Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable of Publishers
        +
        maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
        +
        bufferSize - the number of items to prefetch from each inner Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeArrayDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+ @NonNull
+public static <T> @NonNull Flowable<T> mergeArrayDelayError(int maxConcurrency,
+        int bufferSize,
+        @NonNull Publisher<? extends T>... sources)
        +
        Flattens an array of Publishers into one Publisher, in a way that allows a Subscriber to receive all + successfully emitted items from each of the source Publishers without being interrupted by an error + notification from one of them, while limiting the number of concurrent subscriptions to these Publishers. +

        + This behaves like merge(Publisher) except that if any of the merged Publishers notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged Publishers have finished emitting items. +

        + +

        + Even if multiple merged Publishers send onError notifications, mergeDelayError will only + invoke the onError method of its Subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. All source Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        mergeArrayDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the array of Publishers
        +
        maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
        +
        bufferSize - the number of items to prefetch from each inner Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources,
+        int maxConcurrency)
        +
        Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all + successfully emitted items from each of the source Publishers without being interrupted by an error + notification from one of them, while limiting the number of concurrent subscriptions to these Publishers. +

        + This behaves like merge(Publisher) except that if any of the merged Publishers notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged Publishers have finished emitting items. +

        + +

        + Even if multiple merged Publishers send onError notifications, mergeDelayError will only + invoke the onError method of its Subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. All inner Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable of Publishers
        +
        maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources)
        +
        Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to + receive all successfully emitted items from all of the source Publishers without being interrupted by + an error notification from one of them. +

        + This behaves like merge(Publisher) except that if any of the merged Publishers notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged Publishers have finished emitting items. +

        + +

        + Even if multiple merged Publishers send onError notifications, mergeDelayError will only + invoke the onError method of its Subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The outer Publisher is consumed + in unbounded mode (i.e., no backpressure is applied to it). The inner Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - a Publisher that emits Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources,
+        int maxConcurrency)
        +
        Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to + receive all successfully emitted items from all of the source Publishers without being interrupted by + an error notification from one of them, while limiting the + number of concurrent subscriptions to these Publishers. +

        + This behaves like merge(Publisher) except that if any of the merged Publishers notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged Publishers have finished emitting items. +

        + +

        + Even if multiple merged Publishers send onError notifications, mergeDelayError will only + invoke the onError method of its Subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. Both the outer and inner Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - a Publisher that emits Publishers
        +
        maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeArrayDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+ @NonNull
+public static <T> @NonNull Flowable<T> mergeArrayDelayError(@NonNull Publisher<? extends T>... sources)
        +
        Flattens an array of Publishers into one Flowable, in a way that allows a Subscriber to receive all + successfully emitted items from each of the source Publishers without being interrupted by an error + notification from one of them. +

        + This behaves like merge(Publisher) except that if any of the merged Publishers notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged Publishers have finished emitting items. +

        + +

        + Even if multiple merged Publishers send onError notifications, mergeDelayError will only + invoke the onError method of its Subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. Both the outer and inner Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        mergeArrayDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the array of Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Publisher<? extends T> source1,
+        @NonNull Publisher<? extends T> source2)
        +
        Flattens two Publishers into one Publisher, in a way that allows a Subscriber to receive all + successfully emitted items from each of the source Publishers without being interrupted by an error + notification from one of them. +

        + This behaves like merge(Publisher, Publisher) except that if any of the merged Publishers + notify of an error via onError, mergeDelayError will refrain from + propagating that error notification until all of the merged Publishers have finished emitting items. +

        + +

        + Even if both merged Publishers send onError notifications, mergeDelayError will only + invoke the onError method of its Subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The source Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        source1 - a Publisher to be merged
        +
        source2 - a Publisher to be merged
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1 or source2 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Publisher<? extends T> source1,
+        @NonNull Publisher<? extends T> source2,
+        @NonNull Publisher<? extends T> source3)
        +
        Flattens three Publishers into one Publisher, in a way that allows a Subscriber to receive all + successfully emitted items from all of the source Publishers without being interrupted by an error + notification from one of them. +

        + This behaves like merge(Publisher, Publisher, Publisher) except that if any of the merged + Publishers notify of an error via onError, mergeDelayError will refrain + from propagating that error notification until all of the merged Publishers have finished emitting + items. +

        + +

        + Even if multiple merged Publishers send onError notifications, mergeDelayError will only + invoke the onError method of its Subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The source Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        source1 - a Publisher to be merged
        +
        source2 - a Publisher to be merged
        +
        source3 - a Publisher to be merged
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2 or source3 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Publisher<? extends T> source1,
+        @NonNull Publisher<? extends T> source2,
+        @NonNull Publisher<? extends T> source3,
+        @NonNull Publisher<? extends T> source4)
        +
        Flattens four Publishers into one Publisher, in a way that allows a Subscriber to receive all + successfully emitted items from all of the source Publishers without being interrupted by an error + notification from one of them. +

        + This behaves like merge(Publisher, Publisher, Publisher, Publisher) except that if any of + the merged Publishers notify of an error via onError, mergeDelayError + will refrain from propagating that error notification until all of the merged Publishers have finished + emitting items. +

        + +

        + Even if multiple merged Publishers send onError notifications, mergeDelayError will only + invoke the onError method of its Subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The source Publishers are expected to honor + backpressure; if violated, the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        source1 - a Publisher to be merged
        +
        source2 - a Publisher to be merged
        +
        source3 - a Publisher to be merged
        +
        source4 - a Publisher to be merged
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3 or source4 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        switchOnNext

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> switchOnNext(@NonNull Publisher<? extends Publisher<? extends T>> sources,
+        int bufferSize)
        +
        Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the + most recently emitted of those Publishers. +

        + +

        + switchOnNext subscribes to a Publisher that emits Publishers. Each time it observes one of + these emitted Publishers, the Publisher returned by switchOnNext begins emitting the items + emitted by that Publisher. When a new Publisher is emitted, switchOnNext stops emitting items + from the earlier-emitted Publisher and begins emitting items from the new one. +

        + The resulting Flowable completes if both the outer Publisher and the last inner Publisher, if any, complete. + If the outer Publisher signals an onError, the inner Publisher is canceled and the error delivered in-sequence. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The outer Publisher is consumed in an + unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor + backpressure but it is not enforced; the operator won't signal a MissingBackpressureException + but the violation may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        switchOnNext does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the item type
        +
        Parameters:
        +
        sources - the source Publisher that emits Publishers
        +
        bufferSize - the number of items to prefetch from the inner Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Switch
        +
        +
        • +
      + + + +
        +
      • +

        switchOnNext

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> switchOnNext(@NonNull Publisher<? extends Publisher<? extends T>> sources)
        +
        Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the + most recently emitted of those Publishers. +

        + +

        + switchOnNext subscribes to a Publisher that emits Publishers. Each time it observes one of + these emitted Publishers, the Publisher returned by switchOnNext begins emitting the items + emitted by that Publisher. When a new Publisher is emitted, switchOnNext stops emitting items + from the earlier-emitted Publisher and begins emitting items from the new one. +

        + The resulting Flowable completes if both the outer Publisher and the last inner Publisher, if any, complete. + If the outer Publisher signals an onError, the inner Publisher is canceled and the error delivered in-sequence. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The outer Publisher is consumed in an + unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor + backpressure but it is not enforced; the operator won't signal a MissingBackpressureException + but the violation may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        switchOnNext does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the item type
        +
        Parameters:
        +
        sources - the source Publisher that emits Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Switch
        +
        +
        • +
      + + + +
        +
      • +

        switchOnNextDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> switchOnNextDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources)
        +
        Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the + most recently emitted of those Publishers and delays any exception until all Publishers terminate. +

        + +

        + switchOnNext subscribes to a Publisher that emits Publishers. Each time it observes one of + these emitted Publishers, the Publisher returned by switchOnNext begins emitting the items + emitted by that Publisher. When a new Publisher is emitted, switchOnNext stops emitting items + from the earlier-emitted Publisher and begins emitting items from the new one. +

        + The resulting Flowable completes if both the main Publisher and the last inner Publisher, if any, complete. + If the main Publisher signals an onError, the termination of the last inner Publisher will emit that error as is + or wrapped into a CompositeException along with the other possible errors the former inner Publishers signaled. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The outer Publisher is consumed in an + unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor + backpressure but it is not enforced; the operator won't signal a MissingBackpressureException + but the violation may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        switchOnNextDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the item type
        +
        Parameters:
        +
        sources - the source Publisher that emits Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: Switch
        +
        +
        • +
      + + + +
        +
      • +

        switchOnNextDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> switchOnNextDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources,
+        int prefetch)
        +
        Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the + most recently emitted of those Publishers and delays any exception until all Publishers terminate. +

        + +

        + switchOnNext subscribes to a Publisher that emits Publishers. Each time it observes one of + these emitted Publishers, the Publisher returned by switchOnNext begins emitting the items + emitted by that Publisher. When a new Publisher is emitted, switchOnNext stops emitting items + from the earlier-emitted Publisher and begins emitting items from the new one. +

        + The resulting Flowable completes if both the main Publisher and the last inner Publisher, if any, complete. + If the main Publisher signals an onError, the termination of the last inner Publisher will emit that error as is + or wrapped into a CompositeException along with the other possible errors the former inner Publishers signaled. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The outer Publisher is consumed in an + unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor + backpressure but it is not enforced; the operator won't signal a MissingBackpressureException + but the violation may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        switchOnNextDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the item type
        +
        Parameters:
        +
        sources - the source Publisher that emits Publishers
        +
        prefetch - the number of items to prefetch from the inner Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: Switch
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        unsafeCreate

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=NONE)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> unsafeCreate(@NonNull Publisher<T> onSubscribe)
        +
        Create a Flowable by wrapping a Publisher which has to be implemented according + to the Reactive Streams specification by handling backpressure and + cancellation correctly; no safeguards are provided by the Flowable itself. +
        +
        Backpressure:
        +
        This operator is a pass-through for backpressure and the behavior is determined by the + provided Publisher implementation.
        +
        Scheduler:
        +
        unsafeCreate by default doesn't operate on any particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type emitted
        +
        Parameters:
        +
        onSubscribe - the Publisher instance to wrap
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if onSubscribe is null
        +
        IllegalArgumentException - if onSubscribe is a subclass of Flowable; such + instances don't need conversion and is possibly a port remnant from 1.x or one should use hide() + instead.
        +
        +
        • +
      + + + +
        +
      • +

        using

        +
        @CheckReturnValue
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T,D> @NonNull Flowable<T> using(@NonNull Supplier<? extends D> resourceSupplier,
+        @NonNull Function<? super D,? extends Publisher<? extends T>> sourceSupplier,
+        @NonNull Consumer<? super D> resourceCleanup)
        +
        Constructs a Flowable that creates a dependent resource object, a Publisher with + that resource and calls the provided resourceDisposer function if this inner source terminates or the + downstream cancels the flow. +

        + +

        +
        Backpressure:
        +
        The operator is a pass-through for backpressure and otherwise depends on the + backpressure support of the Publisher returned by the resourceFactory.
        +
        Scheduler:
        +
        using does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the generated Publisher
        +
        D - the type of the resource associated with the output sequence
        +
        Parameters:
        +
        resourceSupplier - the factory function to create a resource object that depends on the Publisher
        +
        sourceSupplier - the factory function to create a Publisher
        +
        resourceCleanup - the function that will dispose of the resource
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if resourceSupplier, sourceSupplier or resourceCleanup is null
        +
        See Also:
        +
        ReactiveX operators documentation: Using
        +
        +
        • +
      + + + +
        +
      • +

        using

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public static <T,D> @NonNull Flowable<T> using(@NonNull Supplier<? extends D> resourceSupplier,
+        @NonNull Function<? super D,? extends Publisher<? extends T>> sourceSupplier,
+        @NonNull Consumer<? super D> resourceCleanup,
+        boolean eager)
        +
        Constructs a Flowable that creates a dependent resource object, a Publisher with + that resource and calls the provided resourceDisposer function if this inner source terminates or the + downstream disposes the flow; doing it before these end-states have been reached if eager == true, after otherwise. +

        + +

        +
        Backpressure:
        +
        The operator is a pass-through for backpressure and otherwise depends on the + backpressure support of the Publisher returned by the resourceFactory.
        +
        Scheduler:
        +
        using does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the generated Publisher
        +
        D - the type of the resource associated with the output sequence
        +
        Parameters:
        +
        resourceSupplier - the factory function to create a resource object that depends on the Publisher
        +
        sourceSupplier - the factory function to create a Publisher
        +
        resourceCleanup - the function that will dispose of the resource
        +
        eager - If true, the resource disposal will happen either on a cancel() call before the upstream is disposed + or just before the emission of a terminal event (onComplete or onError). + If false the resource disposal will happen either on a cancel() call after the upstream is disposed + or just after the emission of a terminal event (onComplete or onError).
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if resourceSupplier, sourceSupplier or resourceCleanup is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: Using
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T,R> @NonNull Flowable<R> zip(@NonNull Iterable<? extends Publisher<? extends T>> sources,
+        @NonNull Function<? super Object[],? extends R> zipper)
        +
        Returns a Flowable that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an Iterable of other Publishers. +

        + zip applies this function in strict sequence, so the first item emitted by the new Publisher + will be the result of the function applied to the first item emitted by each of the source Publishers; + the second item emitted by the new Publisher will be the result of the function applied to the second + item emitted by each of those Publishers; and so forth. +

        + The resulting Flowable returned from zip will invoke onNext as many times as + the number of onNext invocations of the source Publisher that emits the fewest items. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        zip(Arrays.asList(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)), (a) -> a)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +

        + +

        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common value type
        +
        R - the zipped result type
        +
        Parameters:
        +
        sources - an Iterable of source Publishers
        +
        zipper - a function that, when applied to an item emitted by each of the source Publishers, results in + an item that will be emitted by the resulting Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T,R> @NonNull Flowable<R> zip(@NonNull Iterable<? extends Publisher<? extends T>> sources,
+        @NonNull Function<? super Object[],? extends R> zipper,
+        boolean delayError,
+        int bufferSize)
        +
        Returns a Flowable that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an Iterable of other Publishers. +

        + zip applies this function in strict sequence, so the first item emitted by the new Publisher + will be the result of the function applied to the first item emitted by each of the source Publishers; + the second item emitted by the new Publisher will be the result of the function applied to the second + item emitted by each of those Publishers; and so forth. +

        + The resulting Floawble returned from zip will invoke onNext as many times as + the number of onNext invocations of the source Publisher that emits the fewest items. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        zip(Arrays.asList(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)), (a) -> a)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +

        + +

        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common source value type
        +
        R - the zipped result type
        +
        Parameters:
        +
        sources - an Iterable of source Publishers
        +
        zipper - a function that, when applied to an item emitted by each of the source Publishers, results in + an item that will be emitted by the resulting Flowable
        +
        delayError - delay errors signaled by any of the source Publisher until all Publishers terminate
        +
        bufferSize - the number of elements to prefetch from each source Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources or zipper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,R> @NonNull Flowable<R> zip(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull BiFunction<? super T1,? super T2,? extends R> zipper)
        +
        Returns a Flowable that emits the results of a specified combiner function applied to combinations of + two items emitted, in sequence, by two other Publishers. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the new Publisher + will be the result of the function applied to the first item emitted by o1 and the first item + emitted by o2; the second item emitted by the new Publisher will be the result of the function + applied to the second item emitted by o1 and the second item emitted by o2; and so forth. +

        + The resulting Flowable returned from zip will invoke onNext + as many times as the number of onNext invocations of the source Publisher that emits the fewest + items. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), (a, b) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +
        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - a second source Publisher
        +
        zipper - a function that, when applied to an item emitted by each of the source Publishers, results + in an item that will be emitted by the resulting Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,R> @NonNull Flowable<R> zip(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull BiFunction<? super T1,? super T2,? extends R> zipper,
+        boolean delayError)
        +
        Returns a Flowable that emits the results of a specified combiner function applied to combinations of + two items emitted, in sequence, by two other Publishers. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the new Publisher + will be the result of the function applied to the first item emitted by o1 and the first item + emitted by o2; the second item emitted by the new Publisher will be the result of the function + applied to the second item emitted by o1 and the second item emitted by o2; and so forth. +

        + The resulting Flowable returned from zip will invoke onNext + as many times as the number of onNext invocations of the source Publisher that emits the fewest + items. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), (a, b) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +
        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - a second source Publisher
        +
        zipper - a function that, when applied to an item emitted by each of the source Publishers, results + in an item that will be emitted by the resulting Flowable
        +
        delayError - delay errors from any of the source Publishers till the other terminates
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,R> @NonNull Flowable<R> zip(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull BiFunction<? super T1,? super T2,? extends R> zipper,
+        boolean delayError,
+        int bufferSize)
        +
        Returns a Flowable that emits the results of a specified combiner function applied to combinations of + two items emitted, in sequence, by two other Publishers. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the new Publisher + will be the result of the function applied to the first item emitted by o1 and the first item + emitted by o2; the second item emitted by the new Publisher will be the result of the function + applied to the second item emitted by o1 and the second item emitted by o2; and so forth. +

        + The resulting Flowable returned from zip will invoke onNext + as many times as the number of onNext invocations of the source Publisher that emits the fewest + items. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), (a, b) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +
        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - a second source Publisher
        +
        zipper - a function that, when applied to an item emitted by each of the source Publishers, results + in an item that will be emitted by the resulting Flowable
        +
        delayError - delay errors from any of the source Publishers till the other terminates
        +
        bufferSize - the number of elements to prefetch from each source Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2 or zipper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,R> @NonNull Flowable<R> zip(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull Publisher<? extends T3> source3,
+        @NonNull Function3<? super T1,? super T2,? super T3,? extends R> zipper)
        +
        Returns a Flowable that emits the results of a specified combiner function applied to combinations of + three items emitted, in sequence, by three other Publishers. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the new Publisher + will be the result of the function applied to the first item emitted by o1, the first item + emitted by o2, and the first item emitted by o3; the second item emitted by the new + Publisher will be the result of the function applied to the second item emitted by o1, the + second item emitted by o2, and the second item emitted by o3; and so forth. +

        + The resulting Flowable returned from zip will invoke onNext + as many times as the number of onNext invocations of the source Publisher that emits the fewest + items. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +
        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - a second source Publisher
        +
        source3 - a third source Publisher
        +
        zipper - a function that, when applied to an item emitted by each of the source Publishers, results in + an item that will be emitted by the resulting Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,R> @NonNull Flowable<R> zip(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull Publisher<? extends T3> source3,
+        @NonNull Publisher<? extends T4> source4,
+        @NonNull Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)
        +
        Returns a Flowable that emits the results of a specified combiner function applied to combinations of + four items emitted, in sequence, by four other Publishers. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the new Publisher + will be the result of the function applied to the first item emitted by o1, the first item + emitted by o2, the first item emitted by o3, and the first item emitted by 04; + the second item emitted by the new Publisher will be the result of the function applied to the second + item emitted by each of those Publishers; and so forth. +

        + The resulting Flowable returned from zip will invoke onNext + as many times as the number of onNext invocations of the source Publisher that emits the fewest + items. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +
        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - a second source Publisher
        +
        source3 - a third source Publisher
        +
        source4 - a fourth source Publisher
        +
        zipper - a function that, when applied to an item emitted by each of the source Publishers, results in + an item that will be emitted by the resulting Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,R> @NonNull Flowable<R> zip(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull Publisher<? extends T3> source3,
+        @NonNull Publisher<? extends T4> source4,
+        @NonNull Publisher<? extends T5> source5,
+        @NonNull Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)
        +
        Returns a Flowable that emits the results of a specified combiner function applied to combinations of + five items emitted, in sequence, by five other Publishers. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the new Publisher + will be the result of the function applied to the first item emitted by o1, the first item + emitted by o2, the first item emitted by o3, the first item emitted by o4, and + the first item emitted by o5; the second item emitted by the new Publisher will be the result of + the function applied to the second item emitted by each of those Publishers; and so forth. +

        + The resulting Flowable returned from zip will invoke onNext + as many times as the number of onNext invocations of the source Publisher that emits the fewest + items. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +
        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        T5 - the value type of the fifth source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - a second source Publisher
        +
        source3 - a third source Publisher
        +
        source4 - a fourth source Publisher
        +
        source5 - a fifth source Publisher
        +
        zipper - a function that, when applied to an item emitted by each of the source Publishers, results in + an item that will be emitted by the resulting Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,R> @NonNull Flowable<R> zip(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull Publisher<? extends T3> source3,
+        @NonNull Publisher<? extends T4> source4,
+        @NonNull Publisher<? extends T5> source5,
+        @NonNull Publisher<? extends T6> source6,
+        @NonNull Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)
        +
        Returns a Flowable that emits the results of a specified combiner function applied to combinations of + six items emitted, in sequence, by six other Publishers. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the new Publisher + will be the result of the function applied to the first item emitted by each source Publisher, the + second item emitted by the new Publisher will be the result of the function applied to the second item + emitted by each of those Publishers, and so forth. +

        + The resulting Flowable returned from zip will invoke onNext + as many times as the number of onNext invocations of the source Publisher that emits the fewest + items. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +
        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        T5 - the value type of the fifth source
        +
        T6 - the value type of the sixth source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - a second source Publisher
        +
        source3 - a third source Publisher
        +
        source4 - a fourth source Publisher
        +
        source5 - a fifth source Publisher
        +
        source6 - a sixth source Publisher
        +
        zipper - a function that, when applied to an item emitted by each of the source Publishers, results in + an item that will be emitted by the resulting Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6 + or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,T7,R> @NonNull Flowable<R> zip(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull Publisher<? extends T3> source3,
+        @NonNull Publisher<? extends T4> source4,
+        @NonNull Publisher<? extends T5> source5,
+        @NonNull Publisher<? extends T6> source6,
+        @NonNull Publisher<? extends T7> source7,
+        @NonNull Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)
        +
        Returns a Flowable that emits the results of a specified combiner function applied to combinations of + seven items emitted, in sequence, by seven other Publishers. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the new Publisher + will be the result of the function applied to the first item emitted by each source Publisher, the + second item emitted by the new Publisher will be the result of the function applied to the second item + emitted by each of those Publishers, and so forth. +

        + The resulting Flowable returned from zip will invoke onNext + as many times as the number of onNext invocations of the source Publisher that emits the fewest + items. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f, g) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +
        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        T5 - the value type of the fifth source
        +
        T6 - the value type of the sixth source
        +
        T7 - the value type of the seventh source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - a second source Publisher
        +
        source3 - a third source Publisher
        +
        source4 - a fourth source Publisher
        +
        source5 - a fifth source Publisher
        +
        source6 - a sixth source Publisher
        +
        source7 - a seventh source Publisher
        +
        zipper - a function that, when applied to an item emitted by each of the source Publishers, results in + an item that will be emitted by the resulting Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6, + source7 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,T7,T8,R> @NonNull Flowable<R> zip(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull Publisher<? extends T3> source3,
+        @NonNull Publisher<? extends T4> source4,
+        @NonNull Publisher<? extends T5> source5,
+        @NonNull Publisher<? extends T6> source6,
+        @NonNull Publisher<? extends T7> source7,
+        @NonNull Publisher<? extends T8> source8,
+        @NonNull Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)
        +
        Returns a Flowable that emits the results of a specified combiner function applied to combinations of + eight items emitted, in sequence, by eight other Publishers. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the new Publisher + will be the result of the function applied to the first item emitted by each source Publisher, the + second item emitted by the new Publisher will be the result of the function applied to the second item + emitted by each of those Publishers, and so forth. +

        + The resulting Flowable returned from zip will invoke onNext + as many times as the number of onNext invocations of the source Publisher that emits the fewest + items. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f, g, h) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +
        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        T5 - the value type of the fifth source
        +
        T6 - the value type of the sixth source
        +
        T7 - the value type of the seventh source
        +
        T8 - the value type of the eighth source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - a second source Publisher
        +
        source3 - a third source Publisher
        +
        source4 - a fourth source Publisher
        +
        source5 - a fifth source Publisher
        +
        source6 - a sixth source Publisher
        +
        source7 - a seventh source Publisher
        +
        source8 - an eighth source Publisher
        +
        zipper - a function that, when applied to an item emitted by each of the source Publishers, results in + an item that will be emitted by the resulting Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6, + source7, source8 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> @NonNull Flowable<R> zip(@NonNull Publisher<? extends T1> source1,
+        @NonNull Publisher<? extends T2> source2,
+        @NonNull Publisher<? extends T3> source3,
+        @NonNull Publisher<? extends T4> source4,
+        @NonNull Publisher<? extends T5> source5,
+        @NonNull Publisher<? extends T6> source6,
+        @NonNull Publisher<? extends T7> source7,
+        @NonNull Publisher<? extends T8> source8,
+        @NonNull Publisher<? extends T9> source9,
+        @NonNull Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)
        +
        Returns a Flowable that emits the results of a specified combiner function applied to combinations of + nine items emitted, in sequence, by nine other Publishers. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the new Publisher + will be the result of the function applied to the first item emitted by each source Publisher, the + second item emitted by the new Publisher will be the result of the function applied to the second item + emitted by each of those Publishers, and so forth. +

        + The resulting Flowable returned from zip will invoke onNext + as many times as the number of onNext invocations of the source Publisher that emits the fewest + items. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f, g, h, i) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +
        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        T5 - the value type of the fifth source
        +
        T6 - the value type of the sixth source
        +
        T7 - the value type of the seventh source
        +
        T8 - the value type of the eighth source
        +
        T9 - the value type of the ninth source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source Publisher
        +
        source2 - a second source Publisher
        +
        source3 - a third source Publisher
        +
        source4 - a fourth source Publisher
        +
        source5 - a fifth source Publisher
        +
        source6 - a sixth source Publisher
        +
        source7 - a seventh source Publisher
        +
        source8 - an eighth source Publisher
        +
        source9 - a ninth source Publisher
        +
        zipper - a function that, when applied to an item emitted by each of the source Publishers, results in + an item that will be emitted by the resulting Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6, + source7, source8, source9 + or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zipArray

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+public static <T,R> @NonNull Flowable<R> zipArray(@NonNull Function<? super Object[],? extends R> zipper,
+        boolean delayError,
+        int bufferSize,
+        @NonNull Publisher<? extends T>... sources)
        +
        Returns a Flowable that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an array of other Publishers. +

        + zip applies this function in strict sequence, so the first item emitted by the new Publisher + will be the result of the function applied to the first item emitted by each of the source Publishers; + the second item emitted by the new Publisher will be the result of the function applied to the second + item emitted by each of those Publishers; and so forth. +

        + The resulting Flowable returned from zip will invoke onNext as many times as + the number of onNext invocations of the source Publisher that emits the fewest items. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        zip(new Publisher[]{range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)}, (a) ->
+ a)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +

        + +

        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zipArray does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element type
        +
        R - the result type
        +
        Parameters:
        +
        sources - an array of source Publishers
        +
        zipper - a function that, when applied to an item emitted by each of the source Publishers, results in + an item that will be emitted by the resulting Flowable
        +
        delayError - delay errors signaled by any of the source Publisher until all Publishers terminate
        +
        bufferSize - the number of elements to prefetch from each source Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources or zipper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + + + + + +
        +
      • +

        ambWith

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> ambWith(@NonNull Publisher<? extends T> other)
        +
        Mirrors the Publisher (current or provided) that first either emits an item or sends a termination + notification. +

        + +

        + When the current Flowable signals an item or terminates first, the subscription to the other + Publisher is canceled. If the other Publisher signals an item or terminates first, + the subscription to the current Flowable is canceled. +

        +
        Backpressure:
        +
        The operator itself doesn't interfere with backpressure which is determined by the winning + Publisher's backpressure behavior.
        +
        Scheduler:
        +
        ambWith does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        + If the losing Publisher signals an error, the error is routed to the global + error handler via RxJavaPlugins.onError(Throwable). +
        +
        +
        +
        Parameters:
        +
        other - a Publisher competing to react first. A subscription to this provided Publisher will occur after subscribing + to the current Flowable.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if other is null
        +
        See Also:
        +
        ReactiveX operators documentation: Amb
        +
        +
        • +
      + + + + + + + + + + + + + +
        +
      • +

        blockingFirst

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final T blockingFirst(@NonNull T defaultItem)
        +
        Returns the first item emitted by this Flowable, or a default value if it emits no + items. +
        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner + (i.e., no backpressure applied to it).
        +
        Scheduler:
        +
        blockingFirst does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the source signals an error, the operator wraps a checked Exception + into RuntimeException and throws that. Otherwise, RuntimeExceptions and + Errors are rethrown as they are.
        +
        +
        +
        Parameters:
        +
        defaultItem - a default value to return if this Flowable emits no items
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if defaultItem is null
        +
        See Also:
        +
        ReactiveX documentation: First
        +
        +
        • +
      + + + +
        +
      • +

        blockingForEach

        +
        @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final void blockingForEach(@NonNull Consumer<? super T> onNext)
        +
        Consumes the current Flowable in a blocking fashion and invokes the given + Consumer with each upstream item on the current thread until the + upstream terminates. +

        + +

        + Note: the method will only return if the upstream terminates or the current + thread is interrupted. +

        + This method executes the Consumer on the current thread while + subscribe(Consumer) executes the consumer on the original caller thread of the + sequence. +

        +
        Backpressure:
        +
        The operator requests bufferSize() upfront, then 75% of this + amount when 75% is received.
        +
        Scheduler:
        +
        blockingForEach does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the source signals an error, the operator wraps a checked Exception + into RuntimeException and throws that. Otherwise, RuntimeExceptions and + Errors are rethrown as they are.
        +
        +
        +
        Parameters:
        +
        onNext - the Consumer to invoke for each item emitted by the Flowable
        +
        Throws:
        +
        NullPointerException - if onNext is null
        +
        RuntimeException - if an error occurs; Errors and RuntimeExceptions are rethrown + as they are, checked Exceptions are wrapped into RuntimeExceptions
        +
        See Also:
        +
        ReactiveX documentation: Subscribe, +subscribe(Consumer), +blockingForEach(Consumer, int)
        +
        +
        • +
      + + + +
        +
      • +

        blockingForEach

        +
        @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final void blockingForEach(@NonNull Consumer<? super T> onNext,
+        int bufferSize)
        +
        Consumes the current Flowable in a blocking fashion and invokes the given + Consumer with each upstream item on the current thread until the + upstream terminates. +

        + +

        + Note: the method will only return if the upstream terminates or the current + thread is interrupted. +

        + This method executes the Consumer on the current thread while + subscribe(Consumer) executes the consumer on the original caller thread of the + sequence. +

        +
        Backpressure:
        +
        The operator requests the given prefetch amount upfront, then 75% of this + amount when 75% is received.
        +
        Scheduler:
        +
        blockingForEach does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the source signals an error, the operator wraps a checked Exception + into RuntimeException and throws that. Otherwise, RuntimeExceptions and + Errors are rethrown as they are.
        +
        +
        +
        Parameters:
        +
        onNext - the Consumer to invoke for each item emitted by the Flowable
        +
        bufferSize - the number of items to prefetch upfront, then 75% of it after 75% received
        +
        Throws:
        +
        NullPointerException - if onNext is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        RuntimeException - if an error occurs; Errors and RuntimeExceptions are rethrown + as they are, checked Exceptions are wrapped into RuntimeExceptions
        +
        See Also:
        +
        ReactiveX documentation: Subscribe, +subscribe(Consumer)
        +
        +
        • +
      + + + + + + + + + + + + + + + + + +
        +
      • +

        blockingLast

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final T blockingLast(@NonNull T defaultItem)
        +
        Returns the last item emitted by this Flowable, or a default value if it emits no + items. +

        + +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner + (i.e., no backpressure applied to it).
        +
        Scheduler:
        +
        blockingLast does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the source signals an error, the operator wraps a checked Exception + into RuntimeException and throws that. Otherwise, RuntimeExceptions and + Errors are rethrown as they are.
        +
        +
        +
        Parameters:
        +
        defaultItem - a default value to return if this Flowable emits no items
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if defaultItem is null
        +
        See Also:
        +
        ReactiveX documentation: Last
        +
        +
        • +
      + + + +
        +
      • +

        blockingLatest

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Iterable<T> blockingLatest()
        +
        Returns an Iterable that returns the latest item emitted by this Flowable, + waiting if necessary for one to become available. +

        + If this Flowable produces items faster than Iterator.next takes them, + onNext events might be skipped, but onError or onComplete events are not. +

        + Note also that an onNext directly followed by onComplete might hide the onNext + event. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner + (i.e., no backpressure applied to it).
        +
        Scheduler:
        +
        blockingLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Iterable instance
        +
        See Also:
        +
        ReactiveX documentation: First
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        blockingSubscribe

        +
        @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final void blockingSubscribe(@NonNull Consumer<? super T> onNext,
+        @NonNull Consumer<? super Throwable> onError)
        +
        Subscribes to the source and calls the given callbacks on the current thread. +

        + Note that calling this method will block the caller thread until the upstream terminates + normally or with an error. Therefore, calling this method from special threads such as the + Android Main Thread or the Swing Event Dispatch Thread is not recommended. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner + (i.e., no backpressure applied to it).
        +
        Scheduler:
        +
        blockingSubscribe does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        onNext - the callback action for each source value
        +
        onError - the callback action for an error event
        +
        Throws:
        +
        NullPointerException - if onNext or onError is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        blockingSubscribe(Consumer, Consumer, Action)
        +
        +
        • +
      + + + +
        +
      • +

        blockingSubscribe

        +
        @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final void blockingSubscribe(@NonNull Consumer<? super T> onNext,
+        @NonNull Consumer<? super Throwable> onError,
+        int bufferSize)
        +
        Subscribes to the source and calls the given callbacks on the current thread. +

        + Note that calling this method will block the caller thread until the upstream terminates + normally or with an error. Therefore, calling this method from special threads such as the + Android Main Thread or the Swing Event Dispatch Thread is not recommended. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an bounded manner (up to bufferSize + outstanding request amount for items).
        +
        Scheduler:
        +
        blockingSubscribe does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.15 - experimental

        +
        +
        Parameters:
        +
        onNext - the callback action for each source value
        +
        onError - the callback action for an error event
        +
        bufferSize - the size of the buffer
        +
        Throws:
        +
        NullPointerException - if onNext or onError is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        blockingSubscribe(Consumer, Consumer, Action)
        +
        +
        • +
      + + + +
        +
      • +

        blockingSubscribe

        +
        @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final void blockingSubscribe(@NonNull Consumer<? super T> onNext,
+        @NonNull Consumer<? super Throwable> onError,
+        @NonNull Action onComplete)
        +
        Subscribes to the source and calls the given callbacks on the current thread. +

        + Note that calling this method will block the caller thread until the upstream terminates + normally or with an error. Therefore, calling this method from special threads such as the + Android Main Thread or the Swing Event Dispatch Thread is not recommended. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner + (i.e., no backpressure applied to it).
        +
        Scheduler:
        +
        blockingSubscribe does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        onNext - the callback action for each source value
        +
        onError - the callback action for an error event
        +
        onComplete - the callback action for the completion event.
        +
        Throws:
        +
        NullPointerException - if onNext, onError or onComplete is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        blockingSubscribe

        +
        @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final void blockingSubscribe(@NonNull Consumer<? super T> onNext,
+        @NonNull Consumer<? super Throwable> onError,
+        @NonNull Action onComplete,
+        int bufferSize)
        +
        Subscribes to the source and calls the given callbacks on the current thread. +

        + Note that calling this method will block the caller thread until the upstream terminates + normally or with an error. Therefore, calling this method from special threads such as the + Android Main Thread or the Swing Event Dispatch Thread is not recommended. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an bounded manner (up to bufferSize + outstanding request amount for items).
        +
        Scheduler:
        +
        blockingSubscribe does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.15 - experimental

        +
        +
        Parameters:
        +
        onNext - the callback action for each source value
        +
        onError - the callback action for an error event
        +
        onComplete - the callback action for the completion event.
        +
        bufferSize - the size of the buffer
        +
        Throws:
        +
        NullPointerException - if onNext, onError or onComplete is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        blockingSubscribe

        +
        @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+public final void blockingSubscribe(@NonNull Subscriber<? super T> subscriber)
        +
        Subscribes to the source and calls the Subscriber methods on the current thread. +

        + Note that calling this method will block the caller thread until the upstream terminates + normally, with an error or the Subscriber cancels the Subscription it receives via + Subscriber.onSubscribe(Subscription). + Therefore, calling this method from special threads such as the + Android Main Thread or the Swing Event Dispatch Thread is not recommended. +

        +
        Backpressure:
        +
        The supplied Subscriber determines how backpressure is applied.
        +
        Scheduler:
        +
        blockingSubscribe does not operate by default on a particular Scheduler.
        +
        + The cancellation and backpressure is composed through.
        +
        +
        Parameters:
        +
        subscriber - the subscriber to forward events and calls to in the current thread
        +
        Throws:
        +
        NullPointerException - if subscriber is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<List<T>> buffer(int count)
        +
        Returns a Flowable that emits buffers of items it collects from the current Flowable. The resulting + Flowable emits connected, non-overlapping buffers, each containing count items. When the current + Flowable completes, the resulting Flowable emits the current buffer and propagates the notification from the + current Flowable. Note that if the current Flowable issues an onError notification the event is passed on + immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and expects the current Flowable to honor it as + well, although not enforced; violation may lead to MissingBackpressureException somewhere + downstream.
        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - the maximum number of items in each buffer before it should be emitted
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<List<T>> buffer(int count,
+        int skip)
        +
        Returns a Flowable that emits buffers of items it collects from the current Flowable. The resulting + Flowable emits buffers every skip items, each containing count items. When the current + Flowable completes, the resulting Flowable emits the current buffer and propagates the notification from the + current Flowable. Note that if the current Flowable issues an onError notification the event is passed on + immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and expects the current Flowable to honor it as + well, although not enforced; violation may lead to MissingBackpressureException somewhere + downstream.
        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - the maximum size of each buffer before it should be emitted
        +
        skip - how many items emitted by the current Flowable should be skipped before starting a new + buffer. Note that when skip and count are equal, this is the same operation as + buffer(int).
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if count or skip is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <U extends Collection<? super T>> @NonNull Flowable<U> buffer(int count,
+        int skip,
+        @NonNull Supplier<U> bufferSupplier)
        +
        Returns a Flowable that emits buffers of items it collects from the current Flowable. The resulting + Flowable emits buffers every skip items, each containing count items. When the current + Flowable completes, the resulting Flowable emits the current buffer and propagates the notification from the + current Flowable. Note that if the current Flowable issues an onError notification the event is passed on + immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and expects the current Flowable to honor it as + well, although not enforced; violation may lead to MissingBackpressureException somewhere + downstream.
        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the collection subclass type to buffer into
        +
        Parameters:
        +
        count - the maximum size of each buffer before it should be emitted
        +
        skip - how many items emitted by the current Flowable should be skipped before starting a new + buffer. Note that when skip and count are equal, this is the same operation as + buffer(int).
        +
        bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned + as the buffer
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if bufferSupplier is null
        +
        IllegalArgumentException - if count or skip is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U extends Collection<? super T>> @NonNull Flowable<U> buffer(int count,
+        @NonNull Supplier<U> bufferSupplier)
        +
        Returns a Flowable that emits buffers of items it collects from the current Flowable. The resulting + Flowable emits connected, non-overlapping buffers, each containing count items. When the current + Flowable completes, the resulting Flowable emits the current buffer and propagates the notification from the + current Flowable. Note that if the current Flowable issues an onError notification the event is passed on + immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and expects the current Flowable to honor it as + well, although not enforced; violation may lead to MissingBackpressureException somewhere + downstream.
        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the collection subclass type to buffer into
        +
        Parameters:
        +
        count - the maximum number of items in each buffer before it should be emitted
        +
        bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned + as the buffer
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if bufferSupplier is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Flowable<List<T>> buffer(long timespan,
+        long timeskip,
+        @NonNull TimeUnit unit)
        +
        Returns a Flowable that emits buffers of items it collects from the current Flowable. The resulting + Flowable starts a new buffer periodically, as determined by the timeskip argument. It emits + each buffer after a fixed timespan, specified by the timespan argument. When the current + Flowable completes, the resulting Flowable emits the current buffer and propagates the notification from the + current Flowable. Note that if the current Flowable issues an onError notification the event is passed on + immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE + upstream and does not obey downstream requests.
        +
        Scheduler:
        +
        This version of buffer operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted
        +
        timeskip - the period of time after which a new buffer will be created
        +
        unit - the unit of time that applies to the timespan and timeskip arguments
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<List<T>> buffer(long timespan,
+        long timeskip,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns a Flowable that emits buffers of items it collects from the current Flowable. The resulting + Flowable starts a new buffer periodically, as determined by the timeskip argument, and on the + specified scheduler. It emits each buffer after a fixed timespan, specified by the + timespan argument. When the current Flowable completes, the resulting Flowable emits the current buffer + and propagates the notification from the current Flowable. Note that if the current Flowable issues an onError + notification the event is passed on immediately without first emitting the buffer it is in the process of + assembling. +

        + +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE + upstream and does not obey downstream requests.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted
        +
        timeskip - the period of time after which a new buffer will be created
        +
        unit - the unit of time that applies to the timespan and timeskip arguments
        +
        scheduler - the Scheduler to use when determining the end and start of a buffer
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+public final <U extends Collection<? super T>> @NonNull Flowable<U> buffer(long timespan,
+        long timeskip,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        @NonNull Supplier<U> bufferSupplier)
        +
        Returns a Flowable that emits buffers of items it collects from the current Flowable. The resulting + Flowable starts a new buffer periodically, as determined by the timeskip argument, and on the + specified scheduler. It emits each buffer after a fixed timespan, specified by the + timespan argument. When the current Flowable completes, the resulting Flowable emits the current buffer + and propagates the notification from the current Flowable. Note that if the current Flowable issues an onError + notification the event is passed on immediately without first emitting the buffer it is in the process of + assembling. +

        + +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE + upstream and does not obey downstream requests.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Type Parameters:
        +
        U - the collection subclass type to buffer into
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted
        +
        timeskip - the period of time after which a new buffer will be created
        +
        unit - the unit of time that applies to the timespan and timeskip arguments
        +
        scheduler - the Scheduler to use when determining the end and start of a buffer
        +
        bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned + as the buffer
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit, scheduler or bufferSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Flowable<List<T>> buffer(long timespan,
+        @NonNull TimeUnit unit)
        +
        Returns a Flowable that emits buffers of items it collects from the current Flowable. The resulting + Flowable emits connected, non-overlapping buffers, each of a fixed duration specified by the + timespan argument. When the current Flowable completes, the resulting Flowable emits the current buffer + and propagates the notification from the current Flowable. Note that if the current Flowable issues an onError + notification the event is passed on immediately without first emitting the buffer it is in the process of + assembling. +

        + +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE + upstream and does not obey downstream requests.
        +
        Scheduler:
        +
        This version of buffer operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted and replaced with a new + buffer
        +
        unit - the unit of time that applies to the timespan argument
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Flowable<List<T>> buffer(long timespan,
+        @NonNull TimeUnit unit,
+        int count)
        +
        Returns a Flowable that emits buffers of items it collects from the current Flowable. The resulting + Flowable emits connected, non-overlapping buffers, each of a fixed duration specified by the + timespan argument or a maximum size specified by the count argument (whichever is reached + first). When the current Flowable completes, the resulting Flowable emits the current buffer and propagates the + notification from the current Flowable. Note that if the current Flowable issues an onError notification the event + is passed on immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE + upstream and does not obey downstream requests.
        +
        Scheduler:
        +
        This version of buffer operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted and replaced with a new + buffer
        +
        unit - the unit of time which applies to the timespan argument
        +
        count - the maximum size of each buffer before it is emitted
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<List<T>> buffer(long timespan,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        int count)
        +
        Returns a Flowable that emits buffers of items it collects from the current Flowable. The resulting + Flowable emits connected, non-overlapping buffers, each of a fixed duration specified by the + timespan argument as measured on the specified scheduler, or a maximum size specified by + the count argument (whichever is reached first). When the current Flowable completes, the resulting + Flowable emits the current buffer and propagates the notification from the current Flowable. Note that if the + current Flowable issues an onError notification the event is passed on immediately without first emitting the + buffer it is in the process of assembling. +

        + +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE + upstream and does not obey downstream requests.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted and replaced with a new + buffer
        +
        unit - the unit of time which applies to the timespan argument
        +
        scheduler - the Scheduler to use when determining the end and start of a buffer
        +
        count - the maximum size of each buffer before it is emitted
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final <U extends Collection<? super T>> @NonNull Flowable<U> buffer(long timespan,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        int count,
+        @NonNull Supplier<U> bufferSupplier,
+        boolean restartTimerOnMaxSize)
        +
        Returns a Flowable that emits buffers of items it collects from the current Flowable. The resulting + Flowable emits connected, non-overlapping buffers, each of a fixed duration specified by the + timespan argument as measured on the specified scheduler, or a maximum size specified by + the count argument (whichever is reached first). When the current Flowable completes, the resulting + Flowable emits the current buffer and propagates the notification from the current Flowable. Note that if the + current Flowable issues an onError notification the event is passed on immediately without first emitting the + buffer it is in the process of assembling. +

        + +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE + upstream and does not obey downstream requests.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Type Parameters:
        +
        U - the collection subclass type to buffer into
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted and replaced with a new + buffer
        +
        unit - the unit of time which applies to the timespan argument
        +
        scheduler - the Scheduler to use when determining the end and start of a buffer
        +
        count - the maximum size of each buffer before it is emitted
        +
        bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned + as the buffer
        +
        restartTimerOnMaxSize - if true, the time window is restarted when the max capacity of the current buffer + is reached
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit, scheduler or bufferSupplier is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<List<T>> buffer(long timespan,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns a Flowable that emits buffers of items it collects from the current Flowable. The resulting + Flowable emits connected, non-overlapping buffers, each of a fixed duration specified by the + timespan argument and on the specified scheduler. When the current Flowable completes, the + resulting Flowable emits the current buffer and propagates the notification from the current Flowable. Note that + if the current Flowable issues an onError notification the event is passed on immediately without first emitting + the buffer it is in the process of assembling. +

        + +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE + upstream and does not obey downstream requests.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted and replaced with a new + buffer
        +
        unit - the unit of time which applies to the timespan argument
        +
        scheduler - the Scheduler to use when determining the end and start of a buffer
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <TOpening,TClosing> @NonNull Flowable<List<T>> buffer(@NonNull Publisher<? extends TOpening> openingIndicator,
+        @NonNull Function<? super TOpening,? extends Publisher<? extends TClosing>> closingIndicator)
        +
        Returns a Flowable that emits buffers of items it collects from the current Flowable. The resulting + Flowable emits buffers that it creates when the specified openingIndicator Publisher emits an + item, and closes when the Publisher returned from closingIndicator emits an item. If any of the current + PFlowable, openingIndicator or closingIndicator issues an onError notification the event is passed + on immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Backpressure:
        +
        This operator does not support backpressure as it is instead controlled by the given Publishers and + buffers data. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        TOpening - the element type of the buffer-opening Publisher
        +
        TClosing - the element type of the individual buffer-closing Publishers
        +
        Parameters:
        +
        openingIndicator - the Publisher that, when it emits an item, causes a new buffer to be created
        +
        closingIndicator - the Function that is used to produce a Publisher for every buffer created. When this + Publisher emits an item, the associated buffer is emitted.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if openingIndicator or closingIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <TOpening,TClosing,U extends Collection<? super T>> @NonNull Flowable<U> buffer(@NonNull Publisher<? extends TOpening> openingIndicator,
+        @NonNull Function<? super TOpening,? extends Publisher<? extends TClosing>> closingIndicator,
+        @NonNull Supplier<U> bufferSupplier)
        +
        Returns a Flowable that emits buffers of items it collects from the current Flowable. The resulting + Flowable emits buffers that it creates when the specified openingIndicator Publisher emits an + item, and closes when the Publisher returned from closingIndicator emits an item. If any of the current + Flowable, openingIndicator or closingIndicator issues an onError notification the event is passed + on immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Backpressure:
        +
        This operator does not support backpressure as it is instead controlled by the given Publishers and + buffers data. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the collection subclass type to buffer into
        +
        TOpening - the element type of the buffer-opening Publisher
        +
        TClosing - the element type of the individual buffer-closing Publishers
        +
        Parameters:
        +
        openingIndicator - the Publisher that, when it emits an item, causes a new buffer to be created
        +
        closingIndicator - the Function that is used to produce a Publisher for every buffer created. When this + Publisher emits an item, the associated buffer is emitted.
        +
        bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned + as the buffer
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if openingIndicator, closingIndicator or bufferSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <B> @NonNull Flowable<List<T>> buffer(@NonNull Publisher<B> boundaryIndicator)
        +
        Returns a Flowable that emits non-overlapping buffered items from the current Flowable each time the + specified boundary Publisher emits an item. +

        + +

        + Completion of either the source or the boundary Publisher causes the returned Publisher to emit the + latest buffer and complete. If either the current Flowable or the boundary Publisher issues an onError notification + the event is passed on immediately without first emitting the buffer it is in the process of assembling. +

        +
        Backpressure:
        +
        This operator does not support backpressure as it is instead controlled by the Publisher + boundary and buffers data. It requests Long.MAX_VALUE upstream and does not obey + downstream requests.
        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        B - the boundary value type (ignored)
        +
        Parameters:
        +
        boundaryIndicator - the boundary Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if boundaryIndicator is null
        +
        See Also:
        +
        buffer(Publisher, int), +ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <B> @NonNull Flowable<List<T>> buffer(@NonNull Publisher<B> boundaryIndicator,
+        int initialCapacity)
        +
        Returns a Flowable that emits non-overlapping buffered items from the current Flowable each time the + specified boundary Publisher emits an item. +

        + +

        + Completion of either the source or the boundary Publisher causes the returned Publisher to emit the + latest buffer and complete. If either the current Flowable or the boundary Publisher issues an onError notification + the event is passed on immediately without first emitting the buffer it is in the process of assembling. +

        +
        Backpressure:
        +
        This operator does not support backpressure as it is instead controlled by the Publisher + boundary and buffers data. It requests Long.MAX_VALUE upstream and does not obey + downstream requests.
        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        B - the boundary value type (ignored)
        +
        Parameters:
        +
        boundaryIndicator - the boundary Publisher
        +
        initialCapacity - the initial capacity of each buffer chunk
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if boundaryIndicator is null
        +
        IllegalArgumentException - if initialCapacity is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer, +buffer(Publisher)
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <B,U extends Collection<? super T>> @NonNull Flowable<U> buffer(@NonNull Publisher<B> boundaryIndicator,
+        @NonNull Supplier<U> bufferSupplier)
        +
        Returns a Flowable that emits non-overlapping buffered items from the current Flowable each time the + specified boundary Publisher emits an item. +

        + +

        + Completion of either the source or the boundary Publisher causes the returned Publisher to emit the + latest buffer and complete. If either the current Flowable or the boundary Publisher issues an onError notification + the event is passed on immediately without first emitting the buffer it is in the process of assembling. +

        +
        Backpressure:
        +
        This operator does not support backpressure as it is instead controlled by the Publisher + boundary and buffers data. It requests Long.MAX_VALUE upstream and does not obey + downstream requests.
        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the collection subclass type to buffer into
        +
        B - the boundary value type (ignored)
        +
        Parameters:
        +
        boundaryIndicator - the boundary Publisher
        +
        bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned + as the buffer
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if boundaryIndicator or bufferSupplier is null
        +
        See Also:
        +
        buffer(Publisher, int), +ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        cache

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> cache()
        +
        Returns a Flowable that subscribes to this Publisher lazily, caches all of its events + and replays them, in the same order as received, to all the downstream subscribers. +

        + +

        + This is useful when you want a Publisher to cache responses and you can't control the + subscribe/cancel behavior of all the Subscribers. +

        + The operator subscribes only when the first downstream subscriber subscribes and maintains + a single subscription towards this Publisher. In contrast, the operator family of replay() + that return a ConnectableFlowable require an explicit call to ConnectableFlowable.connect(). +

        + Note: You sacrifice the ability to cancel the origin when you use the cache + operator so be careful not to use this operator on Publishers that emit an infinite or very large number + of items that will use up memory. + A possible workaround is to apply takeUntil(Publisher) with a predicate or + another source before (and perhaps after) the application of cache(). + 

        
+ AtomicBoolean shouldStop = new AtomicBoolean();
+
+ source.takeUntil(v -> shouldStop.get())
+       .cache()
+       .takeUntil(v -> shouldStop.get())
+       .subscribe(...);
+
        + Since the operator doesn't allow clearing the cached values either, the possible workaround is + to forget all references to it via onTerminateDetach() applied along with the previous + workaround: + 
        
+ AtomicBoolean shouldStop = new AtomicBoolean();
+
+ source.takeUntil(v -> shouldStop.get())
+       .onTerminateDetach()
+       .cache()
+       .takeUntil(v -> shouldStop.get())
+       .onTerminateDetach()
+       .subscribe(...);
+
        +
        +
        Backpressure:
        +
        The operator consumes this Publisher in an unbounded fashion but respects the backpressure + of each downstream Subscriber individually.
        +
        Scheduler:
        +
        cache does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Flowable instance
        +
        See Also:
        +
        ReactiveX operators documentation: Replay, +takeUntil(Predicate), +takeUntil(Publisher)
        +
        +
        • +
      + + + +
        +
      • +

        cacheWithInitialCapacity

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> cacheWithInitialCapacity(int initialCapacity)
        +
        Returns a Flowable that subscribes to this Publisher lazily, caches all of its events + and replays them, in the same order as received, to all the downstream subscribers. +

        + +

        + This is useful when you want a Publisher to cache responses and you can't control the + subscribe/cancel behavior of all the Subscribers. +

        + The operator subscribes only when the first downstream subscriber subscribes and maintains + a single subscription towards this Publisher. In contrast, the operator family of replay() + that return a ConnectableFlowable require an explicit call to ConnectableFlowable.connect(). +

        + Note: You sacrifice the ability to cancel the origin when you use the cache + operator so be careful not to use this operator on Publishers that emit an infinite or very large number + of items that will use up memory. + A possible workaround is to apply takeUntil(Publisher) with a predicate or + another source before (and perhaps after) the application of cacheWithInitialCapacity(). + 

        
+ AtomicBoolean shouldStop = new AtomicBoolean();
+
+ source.takeUntil(v -> shouldStop.get())
+       .cache()
+       .takeUntil(v -> shouldStop.get())
+       .subscribe(...);
+
        + Since the operator doesn't allow clearing the cached values either, the possible workaround is + to forget all references to it via onTerminateDetach() applied along with the previous + workaround: + 
        
+ AtomicBoolean shouldStop = new AtomicBoolean();
+
+ source.takeUntil(v -> shouldStop.get())
+       .onTerminateDetach()
+       .cache()
+       .takeUntil(v -> shouldStop.get())
+       .onTerminateDetach()
+       .subscribe(...);
+
        +
        +
        Backpressure:
        +
        The operator consumes this Publisher in an unbounded fashion but respects the backpressure + of each downstream Subscriber individually.
        +
        Scheduler:
        +
        cacheWithInitialCapacity does not operate by default on a particular Scheduler.
        +
        +

        + Note: The capacity hint is not an upper bound on cache size. For that, consider + replay(int) in combination with ConnectableFlowable.autoConnect() or similar.

        +
        +
        Parameters:
        +
        initialCapacity - hint for number of items to cache (for optimizing underlying data structure)
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if initialCapacity is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay, +takeUntil(Predicate), +takeUntil(Publisher)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        collect

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <U> @NonNull Single<U> collect(@NonNull Supplier<? extends U> initialItemSupplier,
+        @NonNull BiConsumer<? super U,? super T> collector)
        +
        Collects items emitted by the finite source Publisher into a single mutable data structure and returns + a Single that emits this structure. +

        + +

        + This is a simplified version of reduce that does not need to return the state on each pass. +

        + Note that this operator requires the upstream to signal onComplete for the accumulator object to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        This operator does not support backpressure because by intent it will receive all values and reduce + them to a single onNext.
        +
        Scheduler:
        +
        collect does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the accumulator and output type
        +
        Parameters:
        +
        initialItemSupplier - the mutable data structure that will collect the items
        +
        collector - a function that accepts the state and an emitted item, and modifies state + accordingly
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if initialItemSupplier or collector is null
        +
        See Also:
        +
        ReactiveX operators documentation: Reduce, +collect(Collector)
        +
        +
        • +
      + + + + + +
        +
      • +

        collectInto

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <U> @NonNull Single<U> collectInto(U initialItem,
+        @NonNull BiConsumer<? super U,? super T> collector)
        +
        Collects items emitted by the finite source Publisher into a single mutable data structure and returns + a Single that emits this structure. +

        + +

        + This is a simplified version of reduce that does not need to return the state on each pass. +

        + Note that this operator requires the upstream to signal onComplete for the accumulator object to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        This operator does not support backpressure because by intent it will receive all values and reduce + them to a single onNext.
        +
        Scheduler:
        +
        collectInto does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the accumulator and output type
        +
        Parameters:
        +
        initialItem - the mutable data structure that will collect the items
        +
        collector - a function that accepts the state and an emitted item, and modifies state + accordingly
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if initialItem or collector is null
        +
        See Also:
        +
        ReactiveX operators documentation: Reduce
        +
        +
        • +
      + + + + + + + +
        +
      • +

        concatMap

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> concatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)
        +
        Returns a new Flowable that emits items resulting from applying a function that you supply to each item + emitted by the current Flowable, where that function returns a Publisher, and then emitting the items + that result from concatenating those returned Publishers. +

        + +

        + Note that there is no guarantee where the given mapper function will be executed; it could be on the subscribing thread, + on the upstream thread signaling the new item to be mapped or on the thread where the inner source terminates. To ensure + the mapper function is confined to a known thread, use the concatMap(Function, int, Scheduler) overload. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. Both this and the inner Publishers are + expected to honor backpressure as well. If the current Flowable violates the rule, the operator will + signal a MissingBackpressureException. If any of the inner Publishers doesn't honor + backpressure, that may throw an IllegalStateException when that + Publisher completes.
        +
        Scheduler:
        +
        concatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of the inner Publisher sources and thus the output type
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Flowable, returns a + Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        concatMap

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> concatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        int prefetch)
        +
        Returns a new Flowable that emits items resulting from applying a function that you supply to each item + emitted by the current Flowable, where that function returns a Publisher, and then emitting the items + that result from concatenating those returned Publishers. +

        + +

        + Note that there is no guarantee where the given mapper function will be executed; it could be on the subscribing thread, + on the upstream thread signaling the new item to be mapped or on the thread where the inner source terminates. To ensure + the mapper function is confined to a known thread, use the concatMap(Function, int, Scheduler) overload. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. Both this and the inner Publishers are + expected to honor backpressure as well. If the current Flowable violates the rule, the operator will + signal a MissingBackpressureException. If any of the inner Publishers doesn't honor + backpressure, that may throw an IllegalStateException when that + Publisher completes.
        +
        Scheduler:
        +
        concatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of the inner Publisher sources and thus the output type
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Flowable, returns a + Publisher
        +
        prefetch - the number of elements to prefetch from the current Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap, +concatMap(Function, int, Scheduler)
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        concatMapCompletableDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=FULL)
+ @NonNull
+public final @NonNull Completable concatMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper,
+        boolean tillTheEnd)
        +
        Maps the upstream items into CompletableSources and subscribes to them one after the + other terminates, optionally delaying all errors till both this Flowable and all + inner CompletableSources terminate. +

        + +

        +
        Backpressure:
        +
        The operator expects the upstream to support backpressure. If this Flowable violates the rule, the operator will + signal a MissingBackpressureException.
        +
        Scheduler:
        +
        concatMapCompletableDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a CompletableSource to become the next source to + be subscribed to
        +
        tillTheEnd - If true, errors from this Flowable or any of the + inner CompletableSources are delayed until all + of them terminate. If false, an error from this + Flowable is delayed until the current inner + CompletableSource terminates and only then is + it emitted to the downstream.
        +
        Returns:
        +
        the new Completable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapCompletable(Function)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapCompletableDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=FULL)
+public final @NonNull Completable concatMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper,
+        boolean tillTheEnd,
+        int prefetch)
        +
        Maps the upstream items into CompletableSources and subscribes to them one after the + other terminates, optionally delaying all errors till both this Flowable and all + inner CompletableSources terminate. +

        + +

        +
        Backpressure:
        +
        The operator expects the upstream to support backpressure. If this Flowable violates the rule, the operator will + signal a MissingBackpressureException.
        +
        Scheduler:
        +
        concatMapCompletableDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a CompletableSource to become the next source to + be subscribed to
        +
        tillTheEnd - If true, errors from this Flowable or any of the + inner CompletableSources are delayed until all + of them terminate. If false, an error from this + Flowable is delayed until the current inner + CompletableSource terminates and only then is + it emitted to the downstream.
        +
        prefetch - The number of upstream items to prefetch so that fresh items are + ready to be mapped when a previous CompletableSource terminates. + The operator replenishes after half of the prefetch amount has been consumed + and turned into CompletableSources.
        +
        Returns:
        +
        the new Completable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapCompletable(Function, int)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> concatMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)
        +
        Maps each of the items into a Publisher, subscribes to them one after the other, + one at a time and emits their values in order + while delaying any error from either this or any of the inner Publishers + till all of them terminate. +

        + Note that there is no guarantee where the given mapper function will be executed; it could be on the subscribing thread, + on the upstream thread signaling the new item to be mapped or on the thread where the inner source terminates. To ensure + the mapper function is confined to a known thread, use the concatMapDelayError(Function, boolean, int, Scheduler) overload. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. Both this and the inner Publishers are + expected to honor backpressure as well. If the current Flowable violates the rule, the operator will + signal a MissingBackpressureException. If any of the inner Publishers doesn't honor + backpressure, that may throw an IllegalStateException when that + Publisher completes.
        +
        Scheduler:
        +
        concatMapDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - the function that maps the items of this Publisher into the inner Publishers.
        +
        Returns:
        +
        the new Flowable instance with the concatenation behavior
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        See Also:
        +
        concatMapDelayError(Function, boolean, int, Scheduler)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> concatMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        boolean tillTheEnd,
+        int prefetch)
        +
        Maps each of the items into a Publisher, subscribes to them one after the other, + one at a time and emits their values in order + while delaying any error from either this or any of the inner Publishers + till all of them terminate. +

        + Note that there is no guarantee where the given mapper function will be executed; it could be on the subscribing thread, + on the upstream thread signaling the new item to be mapped or on the thread where the inner source terminates. To ensure + the mapper function is confined to a known thread, use the concatMapDelayError(Function, boolean, int, Scheduler) overload. + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. Both this and the inner Publishers are + expected to honor backpressure as well. If the current Flowable violates the rule, the operator will + signal a MissingBackpressureException. If any of the inner Publishers doesn't honor + backpressure, that may throw an IllegalStateException when that + Publisher completes.
        +
        Scheduler:
        +
        concatMapDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - the function that maps the items of this Publisher into the inner Publishers.
        +
        tillTheEnd - if true, all errors from the outer and inner Publisher sources are delayed until the end, + if false, an error from the main source is signaled when the current inner Publisher source terminates
        +
        prefetch - the number of elements to prefetch from the current Flowable
        +
        Returns:
        +
        the new Flowable instance with the concatenation behavior
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        See Also:
        +
        concatMapDelayError(Function, boolean, int, Scheduler)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+public final <R> @NonNull Flowable<R> concatMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        boolean tillTheEnd,
+        int prefetch,
+        @NonNull Scheduler scheduler)
        +
        Maps each of the upstream items into a Publisher, subscribes to them one after the other, + one at a time and emits their values in order + while executing the mapper function on the designated scheduler, delaying any error from either this or any of the + inner Publishers till all of them terminate. +

        + The difference between concatMapDelayError(Function, boolean, int) and this operator is that this operator guarantees the mapper + function is executed on the specified scheduler. + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. Both this and the inner Publishers are + expected to honor backpressure as well. If the current Flowable violates the rule, the operator will + signal a MissingBackpressureException. If any of the inner Publishers doesn't honor + backpressure, that may throw an IllegalStateException when that + Publisher completes.
        +
        Scheduler:
        +
        concatMapDelayError executes the given mapper function on the provided Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - the function that maps the items of this Publisher into the inner Publishers.
        +
        tillTheEnd - if true, all errors from the outer and inner Publisher sources are delayed until the end, + if false, an error from the main source is signaled when the current inner Publisher source terminates
        +
        prefetch - the number of elements to prefetch from the current Flowable
        +
        scheduler - the scheduler where the mapper function will be executed
        +
        Returns:
        +
        the new Flowable instance with the concatenation behavior
        +
        Throws:
        +
        NullPointerException - if mapper or scheduler is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        concatMapDelayError(Function, boolean, int)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapEager

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> concatMapEager(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)
        +
        Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single + Publisher. +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + inner Publishers. The operator buffers the values emitted by these Publishers and then drains them in + order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources + are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type
        +
        Parameters:
        +
        mapper - the function that maps a sequence of values into a sequence of Publishers that will be + eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatMapEager

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> concatMapEager(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        int maxConcurrency,
+        int prefetch)
        +
        Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single + Publisher. +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + inner Publishers. The operator buffers the values emitted by these Publishers and then drains them in + order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources + are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type
        +
        Parameters:
        +
        mapper - the function that maps a sequence of values into a sequence of Publishers that will be + eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrent subscribed Publishers
        +
        prefetch - hints about the number of expected values from each inner Publisher, must be positive
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if maxConcurrency or prefetch is non-positive
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatMapEagerDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> concatMapEagerDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        boolean tillTheEnd)
        +
        Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single + Publisher. +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + inner Publishers. The operator buffers the values emitted by these Publishers and then drains them in + order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources + are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type
        +
        Parameters:
        +
        mapper - the function that maps a sequence of values into a sequence of Publishers that will be + eagerly concatenated
        +
        tillTheEnd - if true, all errors from the outer and inner Publisher sources are delayed until the end, + if false, an error from the main source is signaled when the current inner Publisher source terminates
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatMapEagerDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> concatMapEagerDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        boolean tillTheEnd,
+        int maxConcurrency,
+        int prefetch)
        +
        Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single + Flowable sequence. +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + inner Publishers. The operator buffers the values emitted by these Publishers and then drains them in + order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources + are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type
        +
        Parameters:
        +
        mapper - the function that maps a sequence of values into a sequence of Publishers that will be + eagerly concatenated
        +
        tillTheEnd - if true, exceptions from the current Flowable and all the inner Publishers are delayed until + all of them terminate, if false, exception from the current Flowable is delayed until the + currently running Publisher terminates
        +
        maxConcurrency - the maximum number of concurrent subscribed Publishers
        +
        prefetch - the number of elements to prefetch from each source Publisher
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if maxConcurrency or prefetch is non-positive
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + + + +
        +
      • +

        concatMapIterable

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <U> @NonNull Flowable<U> concatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper,
+        int prefetch)
        +
        Returns a Flowable that concatenate each item emitted by the current Flowable with the values in an + Iterable corresponding to that item that is generated by a selector. + +
        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The current Flowable is + expected to honor backpressure as well. If the current Flowable violates the rule, the operator will + signal a MissingBackpressureException.
        +
        Scheduler:
        +
        concatMapIterable does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of item emitted by the resulting Flowable
        +
        Parameters:
        +
        mapper - a function that returns an Iterable sequence of values for when given an item emitted by the + current Flowable
        +
        prefetch - the number of elements to prefetch from the current Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + + + + + +
        +
      • +

        concatMapMaybe

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> concatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper,
+        int prefetch)
        +
        Maps the upstream items into MaybeSources and subscribes to them one after the + other succeeds or completes, emits their success value if available or terminates immediately if + either this Flowable or the current inner MaybeSource fail. +

        + +

        +
        Backpressure:
        +
        The operator expects the upstream to support backpressure and honors + the backpressure from downstream. If this Flowable violates the rule, the operator will + signal a MissingBackpressureException.
        +
        Scheduler:
        +
        concatMapMaybe does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the result type of the inner MaybeSources
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a MaybeSource to become the next source to + be subscribed to
        +
        prefetch - The number of upstream items to prefetch so that fresh items are + ready to be mapped when a previous MaybeSource terminates. + The operator replenishes after half of the prefetch amount has been consumed + and turned into MaybeSources.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapMaybe(Function), +concatMapMaybeDelayError(Function, boolean, int)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        concatMapMaybeDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> concatMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper,
+        boolean tillTheEnd)
        +
        Maps the upstream items into MaybeSources and subscribes to them one after the + other terminates, emits their success value if available and optionally delaying all errors + till both this Flowable and all inner MaybeSources terminate. +

        + +

        +
        Backpressure:
        +
        The operator expects the upstream to support backpressure and honors + the backpressure from downstream. If this Flowable violates the rule, the operator will + signal a MissingBackpressureException.
        +
        Scheduler:
        +
        concatMapMaybeDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the result type of the inner MaybeSources
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a MaybeSource to become the next source to + be subscribed to
        +
        tillTheEnd - If true, errors from this Flowable or any of the + inner MaybeSources are delayed until all + of them terminate. If false, an error from this + Flowable is delayed until the current inner + MaybeSource terminates and only then is + it emitted to the downstream.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapMaybe(Function, int), +concatMapMaybeDelayError(Function, boolean, int)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapMaybeDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> concatMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper,
+        boolean tillTheEnd,
+        int prefetch)
        +
        Maps the upstream items into MaybeSources and subscribes to them one after the + other terminates, emits their success value if available and optionally delaying all errors + till both this Flowable and all inner MaybeSources terminate. +

        + +

        +
        Backpressure:
        +
        The operator expects the upstream to support backpressure and honors + the backpressure from downstream. If this Flowable violates the rule, the operator will + signal a MissingBackpressureException.
        +
        Scheduler:
        +
        concatMapMaybeDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the result type of the inner MaybeSources
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a MaybeSource to become the next source to + be subscribed to
        +
        tillTheEnd - If true, errors from this Flowable or any of the + inner MaybeSources are delayed until all + of them terminate. If false, an error from this + Flowable is delayed until the current inner + MaybeSource terminates and only then is + it emitted to the downstream.
        +
        prefetch - The number of upstream items to prefetch so that fresh items are + ready to be mapped when a previous MaybeSource terminates. + The operator replenishes after half of the prefetch amount has been consumed + and turned into MaybeSources.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapMaybe(Function, int)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        concatMapSingle

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> concatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper,
+        int prefetch)
        +
        Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds, emits their success values or terminates immediately if + either this Flowable or the current inner SingleSource fail. +

        + +

        +
        Backpressure:
        +
        The operator expects the upstream to support backpressure and honors + the backpressure from downstream. If this Flowable violates the rule, the operator will + signal a MissingBackpressureException.
        +
        Scheduler:
        +
        concatMapSingle does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the result type of the inner SingleSources
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a SingleSource to become the next source to + be subscribed to
        +
        prefetch - The number of upstream items to prefetch so that fresh items are + ready to be mapped when a previous SingleSource terminates. + The operator replenishes after half of the prefetch amount has been consumed + and turned into SingleSources.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapSingle(Function), +concatMapSingleDelayError(Function, boolean, int)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        concatMapSingleDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> concatMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper,
+        boolean tillTheEnd)
        +
        Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds or fails, emits their success values and optionally delays all errors + till both this Flowable and all inner SingleSources terminate. +

        + +

        +
        Backpressure:
        +
        The operator expects the upstream to support backpressure and honors + the backpressure from downstream. If this Flowable violates the rule, the operator will + signal a MissingBackpressureException.
        +
        Scheduler:
        +
        concatMapSingleDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the result type of the inner SingleSources
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a SingleSource to become the next source to + be subscribed to
        +
        tillTheEnd - If true, errors from this Flowable or any of the + inner SingleSources are delayed until all + of them terminate. If false, an error from this + Flowable is delayed until the current inner + SingleSource terminates and only then is + it emitted to the downstream.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapSingle(Function, int), +concatMapSingleDelayError(Function, boolean, int)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapSingleDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> concatMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper,
+        boolean tillTheEnd,
+        int prefetch)
        +
        Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds or fails, emits their success values and optionally delays errors + till both this Flowable and all inner SingleSources terminate. +

        + +

        +
        Backpressure:
        +
        The operator expects the upstream to support backpressure and honors + the backpressure from downstream. If this Flowable violates the rule, the operator will + signal a MissingBackpressureException.
        +
        Scheduler:
        +
        concatMapSingleDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the result type of the inner SingleSources
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a SingleSource to become the next source to + be subscribed to
        +
        tillTheEnd - If true, errors from this Flowable or any of the + inner SingleSources are delayed until all + of them terminate. If false, an error from this + Flowable is delayed until the current inner + SingleSource terminates and only then is + it emitted to the downstream.
        +
        prefetch - The number of upstream items to prefetch so that fresh items are + ready to be mapped when a previous SingleSource terminates. + The operator replenishes after half of the prefetch amount has been consumed + and turned into SingleSources.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapSingle(Function, int)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        concatWith

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> concatWith(@NonNull SingleSource<? extends T> other)
        +
        Returns a Flowable that emits the items from this Flowable followed by the success item or error event + of the other SingleSource. +

        + +

        +
        Backpressure:
        +
        The operator supports backpressure and makes sure the success item of the other SingleSource + is only emitted when there is a demand for it.
        +
        Scheduler:
        +
        concatWith does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.10 - experimental

        +
        +
        Parameters:
        +
        other - the SingleSource whose signal should be emitted after this Flowable completes normally.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if other is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        concatWith

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> concatWith(@NonNull MaybeSource<? extends T> other)
        +
        Returns a Flowable that emits the items from this Flowable followed by the success item or terminal events + of the other MaybeSource. +

        + +

        +
        Backpressure:
        +
        The operator supports backpressure and makes sure the success item of the other MaybeSource + is only emitted when there is a demand for it.
        +
        Scheduler:
        +
        concatWith does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.10 - experimental

        +
        +
        Parameters:
        +
        other - the MaybeSource whose signal should be emitted after this Flowable completes normally.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if other is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        concatWith

        +
        @CheckReturnValue
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> concatWith(@NonNull CompletableSource other)
        +
        Returns a Flowable that emits items from this Flowable and when it completes normally, the + other CompletableSource is subscribed to and the returned Flowable emits its terminal events. +

        + +

        +
        Backpressure:
        +
        The operator does not interfere with backpressure between the current Flowable and the + downstream consumer (i.e., acts as pass-through). When the operator switches to the + Completable, backpressure is no longer present because Completable doesn't + have items to apply backpressure to.
        +
        Scheduler:
        +
        concatWith does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.10 - experimental

        +
        +
        Parameters:
        +
        other - the CompletableSource to subscribe to once the current Flowable completes normally
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if other is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        debounce

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+public final <U> @NonNull Flowable<T> debounce(@NonNull Function<? super T,? extends Publisher<U>> debounceIndicator)
        +
        Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the + current Flowable that are followed by another item within a computed debounce duration. +

        + +

        + The delivery of the item happens on the thread of the first onNext or onComplete + signal of the generated Publisher sequence, + which if takes too long, a newer item may arrive from the upstream, causing the + generated sequence to get cancelled, which may also interrupt any downstream blocking operation + (yielding an InterruptedException). It is recommended processing items + that may take long time to be moved to another thread via observeOn(io.reactivex.rxjava3.core.Scheduler) applied after + debounce itself. +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses the debounceSelector to mark + boundaries.
        +
        Scheduler:
        +
        This version of debounce does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the debounce value type (ignored)
        +
        Parameters:
        +
        debounceIndicator - function to retrieve a sequence that indicates the throttle duration for each item
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if debounceIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Debounce, +RxJava wiki: Backpressure
        +
        +
        • +
      + + + +
        +
      • +

        debounce

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Flowable<T> debounce(long timeout,
+        @NonNull TimeUnit unit)
        +
        Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the + current Flowable that are followed by newer items before a timeout value expires. The timer resets on + each emission. +

        + Note: If items keep being emitted by the current Flowable faster than the timeout then no items + will be emitted by the resulting Flowable. +

        + +

        + Delivery of the item after the grace period happens on the computation Scheduler's + Worker which if takes too long, a newer item may arrive from the upstream, causing the + Worker's task to get disposed, which may also interrupt any downstream blocking operation + (yielding an InterruptedException). It is recommended processing items + that may take long time to be moved to another thread via observeOn(io.reactivex.rxjava3.core.Scheduler) applied after + debounce itself. +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time to control data flow.
        +
        Scheduler:
        +
        debounce operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timeout - the length of the window of time that must pass after the emission of an item from the current + Flowable in which it emits no items in order for the item to be emitted by the + resulting Flowable
        +
        unit - the unit of time for the specified timeout
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Debounce, +RxJava wiki: Backpressure, +throttleWithTimeout(long, TimeUnit)
        +
        +
        • +
      + + + +
        +
      • +

        debounce

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+public final @NonNull Flowable<T> debounce(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the + current Flowable that are followed by newer items before a timeout value expires on a specified + Scheduler. The timer resets on each emission. +

        + Note: If items keep being emitted by the current Flowable faster than the timeout then no items + will be emitted by the resulting Flowable. +

        + +

        + Delivery of the item after the grace period happens on the given Scheduler's + Worker which if takes too long, a newer item may arrive from the upstream, causing the + Worker's task to get disposed, which may also interrupt any downstream blocking operation + (yielding an InterruptedException). It is recommended processing items + that may take long time to be moved to another thread via observeOn(io.reactivex.rxjava3.core.Scheduler) applied after + debounce itself. +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time to control data flow.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timeout - the time each item has to be "the most recent" of those emitted by the current Flowable to + ensure that it's not dropped
        +
        unit - the unit of time for the specified timeout
        +
        scheduler - the Scheduler to use internally to manage the timers that handle the timeout for each + item
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Debounce, +RxJava wiki: Backpressure, +throttleWithTimeout(long, TimeUnit, Scheduler)
        +
        +
        • +
      + + + +
        +
      • +

        debounce

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+public final @NonNull Flowable<T> debounce(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        @NonNull Consumer<? super T> onDropped)
        +
        Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the + current Flowable that are followed by newer items before a timeout value expires on a specified + Scheduler. The timer resets on each emission. +

        + Note: If items keep being emitted by the current Flowable faster than the timeout then no items + will be emitted by the resulting Flowable. +

        + +

        + Delivery of the item after the grace period happens on the given Scheduler's + Worker which if takes too long, a newer item may arrive from the upstream, causing the + Worker's task to get disposed, which may also interrupt any downstream blocking operation + (yielding an InterruptedException). It is recommended processing items + that may take long time to be moved to another thread via observeOn(io.reactivex.rxjava3.core.Scheduler) applied after + debounce itself. +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time to control data flow.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timeout - the time each item has to be "the most recent" of those emitted by the current Flowable to + ensure that it's not dropped
        +
        unit - the unit of time for the specified timeout
        +
        scheduler - the Scheduler to use internally to manage the timers that handle the timeout for each + item
        +
        onDropped - called with the current entry when it has been replaced by a new one
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null or onDropped is null
        +
        Since:
        +
        3.1.6 - Experimental
        +
        See Also:
        +
        ReactiveX operators documentation: Debounce, +RxJava wiki: Backpressure, +throttleWithTimeout(long, TimeUnit, Scheduler, Consumer)
        +
        +
        • +
      + + + + + + + + + +
        +
      • +

        delay

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <U> @NonNull Flowable<T> delay(@NonNull Function<? super T,? extends Publisher<U>> itemDelayIndicator)
        +
        Returns a Flowable that delays the emissions of the current Flowable via another Publisher on a + per-item basis. +

        + +

        + Note: the resulting Flowable will immediately propagate any onError notification + from the current Flowable. +

        +
        Backpressure:
        +
        The operator doesn't interfere with the backpressure behavior which is determined by the current Flowable. + All of the other Publishers supplied by the function are consumed + in an unbounded manner (i.e., no backpressure applied to them).
        +
        Scheduler:
        +
        This version of delay does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the item delay value type (ignored)
        +
        Parameters:
        +
        itemDelayIndicator - a function that returns a Publisher for each item emitted by the current Flowable, which is + then used to delay the emission of that item by the resulting Flowable until the Publisher + returned from itemDelay emits an item
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if itemDelayIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Delay
        +
        +
        • +
      + + + + + + + +
        +
      • +

        delay

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Flowable<T> delay(long time,
+        @NonNull TimeUnit unit,
+        boolean delayError)
        +
        Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a + specified delay. If delayError is true, error notifications will also be delayed. +

        + +

        +
        Backpressure:
        +
        The operator doesn't interfere with the backpressure behavior which is determined by the current Flowable.
        +
        Scheduler:
        +
        This version of delay operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        time - the delay to shift the source by
        +
        unit - the TimeUnit in which period is defined
        +
        delayError - if true, the upstream exception is signaled with the given delay, after all preceding normal elements, + if false, the upstream exception is signaled immediately
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Delay
        +
        +
        • +
      + + + + + + + +
        +
      • +

        delay

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+public final @NonNull Flowable<T> delay(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean delayError)
        +
        Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a + specified delay. If delayError is true, error notifications will also be delayed. +

        + +

        +
        Backpressure:
        +
        The operator doesn't interfere with the backpressure behavior which is determined by the current Flowable.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        time - the delay to shift the source by
        +
        unit - the time unit of delay
        +
        scheduler - the Scheduler to use for delaying
        +
        delayError - if true, the upstream exception is signaled with the given delay, after all preceding normal elements, + if false, the upstream exception is signaled immediately
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Delay
        +
        +
        • +
      + + + +
        +
      • +

        delay

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,V> @NonNull Flowable<T> delay(@NonNull Publisher<U> subscriptionIndicator,
+        @NonNull Function<? super T,? extends Publisher<V>> itemDelayIndicator)
        +
        Returns a Flowable that delays the subscription to and emissions from the current Flowable via another + Publisher on a per-item basis. +

        + +

        + Note: the resulting Flowable will immediately propagate any onError notification + from the current Flowable. +

        +
        Backpressure:
        +
        The operator doesn't interfere with the backpressure behavior which is determined by the current Flowable. + All of the other Publishers supplied by the functions are consumed + in an unbounded manner (i.e., no backpressure applied to them).
        +
        Scheduler:
        +
        This version of delay does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the subscription delay value type (ignored)
        +
        V - the item delay value type (ignored)
        +
        Parameters:
        +
        subscriptionIndicator - a function that returns a Publisher that triggers the subscription to the current Flowable + once it emits any item
        +
        itemDelayIndicator - a function that returns a Publisher for each item emitted by the current Flowable, which is + then used to delay the emission of that item by the resulting Flowable until the Publisher + returned from itemDelay emits an item
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if subscriptionIndicator and itemDelayIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Delay
        +
        +
        • +
      + + + +
        +
      • +

        delaySubscription

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <U> @NonNull Flowable<T> delaySubscription(@NonNull Publisher<U> subscriptionIndicator)
        +
        Returns a Flowable that delays the subscription to this Publisher + until the other Publisher emits an element or completes normally. +
        +
        Backpressure:
        +
        The operator forwards the backpressure requests to this Publisher once + the subscription happens and requests Long.MAX_VALUE from the other Publisher
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the value type of the other Publisher, irrelevant
        +
        Parameters:
        +
        subscriptionIndicator - the other Publisher that should trigger the subscription + to this Publisher.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if subscriptionIndicator is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        dematerialize

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=PASS_THROUGH)
+public final <R> @NonNull Flowable<R> dematerialize(@NonNull Function<? super T,Notification<R>> selector)
        +
        Returns a Flowable that reverses the effect of materialize by transforming the + Notification objects extracted from the source items via a selector function + into their respective Subscriber signal types. +

        + +

        + The intended use of the selector function is to perform a + type-safe identity mapping (see example) on a source that is already of type + Notification<T>. The Java language doesn't allow + limiting instance methods to a certain generic argument shape, therefore, + a function is used to ensure the conversion remains type safe. +

        + When the upstream signals an onError or + onComplete item, the + returned Flowable cancels of the flow and terminates with that type of terminal event: + 

        
+ Flowable.just(createOnNext(1), createOnComplete(), createOnNext(2))
+ .doOnCancel(() -> System.out.println("Canceled!"));
+ .dematerialize(notification -> notification)
+ .test()
+ .assertResult(1);
+
        + If the upstream signals onError or onComplete directly, the flow is terminated + with the same event. + 
        
+ Flowable.just(createOnNext(1), createOnNext(2))
+ .dematerialize(notification -> notification)
+ .test()
+ .assertResult(1, 2);
+
        + If this behavior is not desired, the completion can be suppressed by applying concatWith(Publisher) + with a never() source. +
        +
        Backpressure:
        +
        The operator doesn't interfere with backpressure which is determined by the current Flowable's + backpressure behavior.
        +
        Scheduler:
        +
        dematerialize does not operate by default on a particular Scheduler.
        +
        +

        History: 2.2.4 - experimental

        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        selector - function that returns the upstream item and should return a Notification to signal + the corresponding Subscriber event to the downstream.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if selector is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        ReactiveX operators documentation: Dematerialize
        +
        +
        • +
      + + + + + + + +
        +
      • +

        distinct

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K> @NonNull Flowable<T> distinct(@NonNull Function<? super T,K> keySelector)
        +
        Returns a Flowable that emits all items emitted by the current Flowable that are distinct according + to a key selector function and based on Object.equals(Object) comparison of the objects + returned by the key selector function. +

        + +

        + It is recommended the keys' class K overrides the default Object.equals() and Object.hashCode() to provide + a meaningful comparison between the key objects as the default Java implementation only considers reference equivalence. +

        + By default, distinct() uses an internal HashSet per Subscriber to remember + previously seen keys and uses Set.add(Object) returning false as the + indicator for duplicates. +

        + Note that this internal HashSet may grow unbounded as keys won't be removed from it by + the operator. Therefore, using very long or infinite upstream (with very distinct keys) may lead + to OutOfMemoryError. +

        + Customizing the retention policy can happen only by providing a custom Collection implementation + to the distinct(Function, Supplier) overload. +

        +
        Backpressure:
        +
        The operator doesn't interfere with backpressure which is determined by the current Flowable's + backpressure behavior.
        +
        Scheduler:
        +
        distinct does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        Parameters:
        +
        keySelector - a function that projects an emitted item to a key value that is used to decide whether an item + is distinct from another one or not
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if keySelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: Distinct, +distinct(Function, Supplier)
        +
        +
        • +
      + + + +
        +
      • +

        distinct

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K> @NonNull Flowable<T> distinct(@NonNull Function<? super T,K> keySelector,
+        @NonNull Supplier<? extends Collection<? super K>> collectionSupplier)
        +
        Returns a Flowable that emits all items emitted by the current Flowable that are distinct according + to a key selector function and based on Object.equals(Object) comparison of the objects + returned by the key selector function. +

        + +

        + It is recommended the keys' class K overrides the default Object.equals() and Object.hashCode() to provide + a meaningful comparison between the key objects as the default Java implementation only considers reference equivalence. +

        +
        Backpressure:
        +
        The operator doesn't interfere with backpressure which is determined by the current Flowable's + backpressure behavior.
        +
        Scheduler:
        +
        distinct does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        Parameters:
        +
        keySelector - a function that projects an emitted item to a key value that is used to decide whether an item + is distinct from another one or not
        +
        collectionSupplier - function called for each individual Subscriber to return a Collection subtype for holding the extracted + keys and whose add() method's return indicates uniqueness.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if keySelector or collectionSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: Distinct
        +
        +
        • +
      + + + +
        +
      • +

        distinctUntilChanged

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> distinctUntilChanged()
        +
        Returns a Flowable that emits all items emitted by the current Flowable that are distinct from their + immediate predecessors based on Object.equals(Object) comparison. +

        + +

        + It is recommended the elements' class T in the flow overrides the default Object.equals() to provide + a meaningful comparison between items as the default Java implementation only considers reference equivalence. + Alternatively, use the distinctUntilChanged(BiPredicate) overload and provide a comparison function + in case the class T can't be overridden with custom equals() or the comparison itself + should happen on different terms or properties of the class T. +

        + Note that the operator always retains the latest item from upstream regardless of the comparison result + and uses it in the next comparison with the next upstream item. +

        + Note that if element type T in the flow is mutable, the comparison of the previous and current + item may yield unexpected results if the items are mutated externally. Common cases are mutable + CharSequences or Lists where the objects will actually have the same + references when they are modified and distinctUntilChanged will evaluate subsequent items as same. + To avoid such situation, it is recommended that mutable data is converted to an immutable one, + for example using map(CharSequence::toString) or map(list -> Collections.unmodifiableList(new ArrayList<>(list))). +

        +
        Backpressure:
        +
        The operator doesn't interfere with backpressure which is determined by the current Flowable's + backpressure behavior.
        +
        Scheduler:
        +
        distinctUntilChanged does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Flowable instance
        +
        See Also:
        +
        ReactiveX operators documentation: Distinct, +distinctUntilChanged(BiPredicate)
        +
        +
        • +
      + + + +
        +
      • +

        distinctUntilChanged

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K> @NonNull Flowable<T> distinctUntilChanged(@NonNull Function<? super T,K> keySelector)
        +
        Returns a Flowable that emits all items emitted by the current Flowable that are distinct from their + immediate predecessors, according to a key selector function and based on Object.equals(Object) comparison + of those objects returned by the key selector function. +

        + +

        + It is recommended the keys' class K overrides the default Object.equals() to provide + a meaningful comparison between the key objects as the default Java implementation only considers reference equivalence. + Alternatively, use the distinctUntilChanged(BiPredicate) overload and provide a comparison function + in case the class K can't be overridden with custom equals() or the comparison itself + should happen on different terms or properties of the item class T (for which the keys can be + derived via a similar selector). +

        + Note that the operator always retains the latest key from upstream regardless of the comparison result + and uses it in the next comparison with the next key derived from the next upstream item. +

        + Note that if element type T in the flow is mutable, the comparison of the previous and current + item may yield unexpected results if the items are mutated externally. Common cases are mutable + CharSequences or Lists where the objects will actually have the same + references when they are modified and distinctUntilChanged will evaluate subsequent items as same. + To avoid such situation, it is recommended that mutable data is converted to an immutable one, + for example using map(CharSequence::toString) or map(list -> Collections.unmodifiableList(new ArrayList<>(list))). +

        +
        Backpressure:
        +
        The operator doesn't interfere with backpressure which is determined by the current Flowable's + backpressure behavior.
        +
        Scheduler:
        +
        distinctUntilChanged does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        Parameters:
        +
        keySelector - a function that projects an emitted item to a key value that is used to decide whether an item + is distinct from another one or not
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if keySelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: Distinct
        +
        +
        • +
      + + + +
        +
      • +

        distinctUntilChanged

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> distinctUntilChanged(@NonNull BiPredicate<? super T,? super T> comparer)
        +
        Returns a Flowable that emits all items emitted by the current Flowable that are distinct from their + immediate predecessors when compared with each other via the provided comparator function. +

        + +

        + Note that the operator always retains the latest item from upstream regardless of the comparison result + and uses it in the next comparison with the next upstream item. +

        + Note that if element type T in the flow is mutable, the comparison of the previous and current + item may yield unexpected results if the items are mutated externally. Common cases are mutable + CharSequences or Lists where the objects will actually have the same + references when they are modified and distinctUntilChanged will evaluate subsequent items as same. + To avoid such situation, it is recommended that mutable data is converted to an immutable one, + for example using map(CharSequence::toString) or map(list -> Collections.unmodifiableList(new ArrayList<>(list))). +

        +
        Backpressure:
        +
        The operator doesn't interfere with backpressure which is determined by the current Flowable's + backpressure behavior.
        +
        Scheduler:
        +
        distinctUntilChanged does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        comparer - the function that receives the previous item and the current item and is + expected to return true if the two are equal, thus skipping the current value.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if comparer is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: Distinct
        +
        +
        • +
      + + + +
        +
      • +

        doFinally

        +
        @CheckReturnValue
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> doFinally(@NonNull Action onFinally)
        +
        Calls the specified action after this Flowable signals onError or onComplete or gets canceled by + the downstream. +

        In case of a race between a terminal event and a cancellation, the provided onFinally action + is executed once per subscription. +

        Note that the onFinally action is shared between subscriptions and as such + should be thread-safe. +

        +
        Backpressure:
        +
        The operator doesn't interfere with backpressure which is determined by the current Flowable's backpressure + behavior.
        +
        Scheduler:
        +
        doFinally does not operate by default on a particular Scheduler.
        +
        Operator-fusion:
        +
        This operator supports normal and conditional Subscribers as well as boundary-limited + synchronous or asynchronous queue-fusion.
        +
        +

        History: 2.0.1 - experimental

        +
        +
        Parameters:
        +
        onFinally - the action called when this Flowable terminates or gets canceled
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if onFinally is null
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + +
        +
      • +

        doAfterNext

        +
        @CheckReturnValue
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> doAfterNext(@NonNull Consumer<? super T> onAfterNext)
        +
        Calls the specified consumer with the current item after this item has been emitted to the downstream. +

        Note that the onAfterNext action is shared between subscriptions and as such + should be thread-safe. +

        +
        Backpressure:
        +
        The operator doesn't interfere with backpressure which is determined by the current Flowable's backpressure + behavior.
        +
        Scheduler:
        +
        doAfterNext does not operate by default on a particular Scheduler.
        +
        Operator-fusion:
        +
        This operator supports normal and conditional Subscribers as well as boundary-limited + synchronous or asynchronous queue-fusion.
        +
        +

        History: 2.0.1 - experimental

        +
        +
        Parameters:
        +
        onAfterNext - the Consumer that will be called after emitting an item from upstream to the downstream
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if onAfterNext is null
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + + + + + +
        +
      • +

        doOnCancel

        +
        @CheckReturnValue
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> doOnCancel(@NonNull Action onCancel)
        +
        Calls the cancel Action if the downstream cancels the sequence. +

        + +

        + The action is shared between subscriptions and thus may be called concurrently from multiple + threads; the action must be thread-safe. +

        + If the action throws a runtime exception, that exception is rethrown by the onCancel() call, + sometimes as a CompositeException if there were multiple exceptions along the way. +

        +
        Backpressure:
        +
        doOnCancel does not interact with backpressure requests or value delivery; backpressure + behavior is preserved between its upstream and its downstream.
        +
        Scheduler:
        +
        doOnCancel does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        onCancel - the action that gets called when the current Flowable's Subscription is canceled
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if onCancel is null
        +
        See Also:
        +
        ReactiveX operators documentation: Do
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        doOnEach

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> doOnEach(@NonNull Subscriber<? super T> subscriber)
        +
        Calls the appropriate methods of the given Subscriber when the current Flowable signals events before forwarding it + to the downstream. +

        + In case the onError of the supplied Subscriber throws, the downstream will receive a composite + exception containing the original exception and the exception thrown by onError. If either the + onNext or the onComplete method of the supplied Subscriber throws, the downstream will be + terminated and will receive this thrown exception. +

        + +

        +
        Backpressure:
        +
        The operator doesn't interfere with backpressure which is determined by the current Flowable's + backpressure behavior.
        +
        Scheduler:
        +
        doOnEach does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        subscriber - the Subscriber to be notified about onNext, onError and onComplete events on its + respective methods before the actual downstream Subscriber gets notified.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if subscriber is null
        +
        See Also:
        +
        ReactiveX operators documentation: Do
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)
        +
        Returns a Flowable that emits items based on applying a function that you supply to each item emitted + by the current Flowable, where that function returns a Publisher, and then merging those resulting + Publishers and emitting the results of this merger. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The upstream Flowable is consumed + in a bounded manner (up to bufferSize() outstanding request amount for items). + The inner Publishers are expected to honor backpressure; if violated, + the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type of the inner Publishers and the output type
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Flowable, returns a + Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        boolean delayErrors)
        +
        Returns a Flowable that emits items based on applying a function that you supply to each item emitted + by the current Flowable, where that function returns a Publisher, and then merging those resulting + Publishers and emitting the results of this merger. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The upstream Flowable is consumed + in a bounded manner (up to bufferSize() outstanding request amount for items). + The inner Publishers are expected to honor backpressure; if violated, + the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type of the inner Publishers and the output type
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Flowable, returns a + Publisher
        +
        delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate + if false, the first one signaling an exception will terminate the whole sequence immediately
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        int maxConcurrency)
        +
        Returns a Flowable that emits items based on applying a function that you supply to each item emitted + by the current Flowable, where that function returns a Publisher, and then merging those resulting + Publishers and emitting the results of this merger, while limiting the maximum number of concurrent + subscriptions to these Publishers. + + +
        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The upstream Flowable is consumed + in a bounded manner (up to maxConcurrency outstanding request amount for items). + The inner Publishers are expected to honor backpressure; if violated, + the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type of the inner Publishers and the output type
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Flowable, returns a + Publisher
        +
        maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        boolean delayErrors,
+        int maxConcurrency)
        +
        Returns a Flowable that emits items based on applying a function that you supply to each item emitted + by the current Flowable, where that function returns a Publisher, and then merging those resulting + Publishers and emitting the results of this merger, while limiting the maximum number of concurrent + subscriptions to these Publishers. + + +
        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The upstream Flowable is consumed + in a bounded manner (up to maxConcurrency outstanding request amount for items). + The inner Publishers are expected to honor backpressure; if violated, + the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type of the inner Publishers and the output type
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Flowable, returns a + Publisher
        +
        maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
        +
        delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate + if false, the first one signaling an exception will terminate the whole sequence immediately
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        boolean delayErrors,
+        int maxConcurrency,
+        int bufferSize)
        +
        Returns a Flowable that emits items based on applying a function that you supply to each item emitted + by the current Flowable, where that function returns a Publisher, and then merging those resulting + Publishers and emitting the results of this merger, while limiting the maximum number of concurrent + subscriptions to these Publishers. + + +
        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The upstream Flowable is consumed + in a bounded manner (up to maxConcurrency outstanding request amount for items). + The inner Publishers are expected to honor backpressure; if violated, + the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type of the inner Publishers and the output type
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Flowable, returns a + Publisher
        +
        maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
        +
        delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate + if false, the first one signaling an exception will terminate the whole sequence immediately
        +
        bufferSize - the number of elements to prefetch from each inner Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> onNextMapper,
+        @NonNull Function<? super Throwable,? extends Publisher<? extends R>> onErrorMapper,
+        @NonNull Supplier<? extends Publisher<? extends R>> onCompleteSupplier)
        +
        Returns a Flowable that applies a function to each item emitted or notification raised by the current + Flowable and then flattens the Publishers returned from these functions and emits the resulting items. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The upstream Flowable is consumed + in a bounded manner (up to bufferSize() outstanding request amount for items). + The inner Publishers are expected to honor backpressure; if violated, + the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result type
        +
        Parameters:
        +
        onNextMapper - a function that returns a Publisher to merge for each item emitted by the current Flowable
        +
        onErrorMapper - a function that returns a Publisher to merge for an onError notification from the current + Flowable
        +
        onCompleteSupplier - a function that returns a Publisher to merge for an onComplete notification from the current + Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if onNextMapper, onErrorMapper or onCompleteSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> onNextMapper,
+        @NonNull Function<Throwable,? extends Publisher<? extends R>> onErrorMapper,
+        @NonNull Supplier<? extends Publisher<? extends R>> onCompleteSupplier,
+        int maxConcurrency)
        +
        Returns a Flowable that applies a function to each item emitted or notification raised by the current + Flowable and then flattens the Publishers returned from these functions and emits the resulting items, + while limiting the maximum number of concurrent subscriptions to these Publishers. + + +
        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The upstream Flowable is consumed + in a bounded manner (up to maxConcurrency outstanding request amount for items). + The inner Publishers are expected to honor backpressure; if violated, + the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result type
        +
        Parameters:
        +
        onNextMapper - a function that returns a Publisher to merge for each item emitted by the current Flowable
        +
        onErrorMapper - a function that returns a Publisher to merge for an onError notification from the current + Flowable
        +
        onCompleteSupplier - a function that returns a Publisher to merge for an onComplete notification from the current + Flowable
        +
        maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if onNextMapper, onErrorMapper or onCompleteSupplier is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Flowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends U>> mapper,
+        @NonNull BiFunction<? super T,? super U,? extends R> combiner)
        +
        Returns a Flowable that emits the results of a specified function to the pair of values emitted by the + current Flowable and a specified collection Publisher. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The upstream Flowable is consumed + in a bounded manner (up to maxConcurrency outstanding request amount for items). + The inner Publishers are expected to honor backpressure; if violated, + the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the inner Publishers
        +
        R - the type of items emitted by the combiner function
        +
        Parameters:
        +
        mapper - a function that returns a Publisher for each item emitted by the current Flowable
        +
        combiner - a function that combines one item emitted by each of the source and collection Publishers and + returns an item to be emitted by the resulting Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Flowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends U>> mapper,
+        @NonNull BiFunction<? super T,? super U,? extends R> combiner,
+        boolean delayErrors)
        +
        Returns a Flowable that emits the results of a specified function to the pair of values emitted by the + current Flowable and a specified inner Publisher. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The upstream Flowable is consumed + in a bounded manner (up to bufferSize() outstanding request amount for items). + The inner Publishers are expected to honor backpressure; if violated, + the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the inner Publishers
        +
        R - the type of items emitted by the combiner functions
        +
        Parameters:
        +
        mapper - a function that returns a Publisher for each item emitted by the current Flowable
        +
        combiner - a function that combines one item emitted by each of the source and collection Publishers and + returns an item to be emitted by the resulting Flowable
        +
        delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate + if false, the first one signaling an exception will terminate the whole sequence immediately
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Flowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends U>> mapper,
+        @NonNull BiFunction<? super T,? super U,? extends R> combiner,
+        boolean delayErrors,
+        int maxConcurrency)
        +
        Returns a Flowable that emits the results of a specified function to the pair of values emitted by the + current Flowable and a specified collection Publisher, while limiting the maximum number of concurrent + subscriptions to these Publishers. + + +
        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The upstream Flowable is consumed + in a bounded manner (up to maxConcurrency outstanding request amount for items). + The inner Publishers are expected to honor backpressure; if violated, + the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the inner Publishers
        +
        R - the type of items emitted by the combiner function
        +
        Parameters:
        +
        mapper - a function that returns a Publisher for each item emitted by the current Flowable
        +
        combiner - a function that combines one item emitted by each of the source and collection Publishers and + returns an item to be emitted by the resulting Flowable
        +
        maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
        +
        delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate + if false, the first one signaling an exception will terminate the whole sequence immediately
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper or combiner is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <U,R> @NonNull Flowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends U>> mapper,
+        @NonNull BiFunction<? super T,? super U,? extends R> combiner,
+        boolean delayErrors,
+        int maxConcurrency,
+        int bufferSize)
        +
        Returns a Flowable that emits the results of a specified function to the pair of values emitted by the + current Flowable and a specified collection Publisher, while limiting the maximum number of concurrent + subscriptions to these Publishers. + + +
        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The upstream Flowable is consumed + in a bounded manner (up to maxConcurrency outstanding request amount for items). + The inner Publishers are expected to honor backpressure; if violated, + the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the inner Publishers
        +
        R - the type of items emitted by the combiner function
        +
        Parameters:
        +
        mapper - a function that returns a Publisher for each item emitted by the current Flowable
        +
        combiner - a function that combines one item emitted by each of the source and collection Publishers and + returns an item to be emitted by the resulting Flowable
        +
        maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
        +
        delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate + if false, the first one signaling an exception will terminate the whole sequence immediately
        +
        bufferSize - the number of elements to prefetch from the inner Publishers.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper or combiner is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Flowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends U>> mapper,
+        @NonNull BiFunction<? super T,? super U,? extends R> combiner,
+        int maxConcurrency)
        +
        Returns a Flowable that emits the results of a specified function to the pair of values emitted by the + current Flowable and a specified collection Publisher, while limiting the maximum number of concurrent + subscriptions to these Publishers. + + +
        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The upstream Flowable is consumed + in a bounded manner (up to bufferSize() outstanding request amount for items). + The inner Publishers are expected to honor backpressure; if violated, + the operator may signal MissingBackpressureException.
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the inner Publishers
        +
        R - the type of items emitted by the combiner function
        +
        Parameters:
        +
        mapper - a function that returns a Publisher for each item emitted by the current Flowable
        +
        combiner - a function that combines one item emitted by each of the source and collection Publishers and + returns an item to be emitted by the resulting Flowable
        +
        maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper or combiner is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + + + + + +
        +
      • +

        flatMapCompletable

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final @NonNull Completable flatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper,
+        boolean delayErrors,
+        int maxConcurrency)
        +
        Maps each element of the upstream Flowable into CompletableSources, subscribes to them and + waits until the upstream and all CompletableSources complete, optionally delaying all errors. +
        +
        Backpressure:
        +
        If maxConcurrency == Integer.MAX_VALUE the operator consumes the upstream in an unbounded manner. + Otherwise, the operator expects the upstream to honor backpressure. If the upstream doesn't support backpressure + the operator behaves as if maxConcurrency == Integer.MAX_VALUE was used.
        +
        Scheduler:
        +
        flatMapCompletable does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        mapper - the function that received each source value and transforms them into CompletableSources.
        +
        delayErrors - if true, errors from the upstream and inner CompletableSources are delayed until each of them + terminates.
        +
        maxConcurrency - the maximum number of active subscriptions to the CompletableSources.
        +
        Returns:
        +
        the new Completable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        flatMapIterable

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <U,V> @NonNull Flowable<V> flatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper,
+        @NonNull BiFunction<? super T,? super U,? extends V> combiner)
        +
        Merges Iterables generated by a mapper Function for each individual item emitted by + the current Flowable into a single Flowable sequence where the resulting items will + be the combination of the original item and each inner item of the respective Iterable as returned + by the resultSelector BiFunction. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and the current Flowables is + consumed in a bounded manner (requesting bufferSize() items upfront, then 75% of it after 75% received).
        +
        Scheduler:
        +
        flatMapIterable does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the element type of the Iterables
        +
        V - the output type as determined by the resultSelector function
        +
        Parameters:
        +
        mapper - a function that returns an Iterable sequence of values for each item emitted by the current + Flowable
        +
        combiner - a function that returns an item based on the item emitted by the current Flowable and the + Iterable returned for that item by the collectionSelector
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMapIterable

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <U,V> @NonNull Flowable<V> flatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper,
+        @NonNull BiFunction<? super T,? super U,? extends V> combiner,
+        int prefetch)
        +
        Merges Iterables generated by a mapper Function for each individual item emitted by + the current Flowable into a single Flowable sequence where the resulting items will + be the combination of the original item and each inner item of the respective Iterable as returned + by the resultSelector BiFunction. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The current Flowables is + expected to honor backpressure as well. If the current Flowable violates the rule, the operator will + signal a MissingBackpressureException.
        +
        Scheduler:
        +
        flatMapIterable does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the element type of the inner Iterable sequences
        +
        V - the type of item emitted by the resulting Flowable
        +
        Parameters:
        +
        mapper - a function that returns an Iterable sequence of values for when given an item emitted by the + current Flowable
        +
        combiner - a function that returns an item based on the item emitted by the current Flowable and the + Iterable returned for that item by the collectionSelector
        +
        prefetch - the number of elements to prefetch from the current Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper or combiner is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMapMaybe

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> flatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)
        +
        Maps each element of the upstream Flowable into MaybeSources, subscribes to all of them + and merges their onSuccess values, in no particular order, into a single Flowable sequence. +
        +
        Backpressure:
        +
        The operator consumes the upstream in an unbounded manner.
        +
        Scheduler:
        +
        flatMapMaybe does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - the function that received each source value and transforms them into MaybeSources.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        +
        • +
      + + + +
        +
      • +

        flatMapMaybe

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> flatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper,
+        boolean delayErrors,
+        int maxConcurrency)
        +
        Maps each element of the upstream Flowable into MaybeSources, subscribes to at most + maxConcurrency MaybeSources at a time and merges their onSuccess values, + in no particular order, into a single Flowable sequence, optionally delaying all errors. +
        +
        Backpressure:
        +
        If maxConcurrency == Integer.MAX_VALUE the operator consumes the upstream in an unbounded manner. + Otherwise, the operator expects the upstream to honor backpressure. If the upstream doesn't support backpressure + the operator behaves as if maxConcurrency == Integer.MAX_VALUE was used.
        +
        Scheduler:
        +
        flatMapMaybe does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - the function that received each source value and transforms them into MaybeSources.
        +
        delayErrors - if true, errors from the upstream and inner MaybeSources are delayed until each of them + terminates.
        +
        maxConcurrency - the maximum number of active subscriptions to the MaybeSources.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        flatMapSingle

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> flatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)
        +
        Maps each element of the upstream Flowable into SingleSources, subscribes to all of them + and merges their onSuccess values, in no particular order, into a single Flowable sequence. +
        +
        Backpressure:
        +
        The operator consumes the upstream in an unbounded manner.
        +
        Scheduler:
        +
        flatMapSingle does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - the function that received each source value and transforms them into SingleSources.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        +
        • +
      + + + +
        +
      • +

        flatMapSingle

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> flatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper,
+        boolean delayErrors,
+        int maxConcurrency)
        +
        Maps each element of the upstream Flowable into SingleSources, subscribes to at most + maxConcurrency SingleSources at a time and merges their onSuccess values, + in no particular order, into a single Flowable sequence, optionally delaying all errors. +
        +
        Backpressure:
        +
        If maxConcurrency == Integer.MAX_VALUE the operator consumes the upstream in an unbounded manner. + Otherwise, the operator expects the upstream to honor backpressure. If the upstream doesn't support backpressure + the operator behaves as if maxConcurrency == Integer.MAX_VALUE was used.
        +
        Scheduler:
        +
        flatMapSingle does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - the function that received each source value and transforms them into SingleSources.
        +
        delayErrors - if true, errors from the upstream and inner SingleSources are delayed until each of them + terminates.
        +
        maxConcurrency - the maximum number of active subscriptions to the SingleSources.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        groupBy

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K> @NonNull Flowable<GroupedFlowable<K,T>> groupBy(@NonNull Function<? super T,? extends K> keySelector)
        +
        Groups the items emitted by the current Flowable according to a specified criterion, and emits these + grouped items as GroupedFlowables. The emitted GroupedFlowable allows only a single + Subscriber during its lifetime and if this Subscriber cancels before the + source terminates, the next emission by the source having the same key will trigger a new + GroupedFlowable emission. +

        + +

        + Note: A GroupedFlowable will cache the items it is to emit until such time as it + is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those + GroupedFlowables that do not concern you. Instead, you can signal to them that they may + discard their buffers by applying an operator like ignoreElements() to them. +

        + Note that the GroupedFlowables should be subscribed to as soon as possible, otherwise, + the unconsumed groups may starve other groups due to the internal backpressure + coordination of the groupBy operator. Such hangs can be usually avoided by using + flatMap(Function, int) or concatMapEager(Function, int, int) and overriding the default maximum concurrency + value to be greater or equal to the expected number of groups, possibly using + Integer.MAX_VALUE if the number of expected groups is unknown. +

        + Note also that ignoring groups or subscribing later (i.e., on another thread) will result in + so-called group abandonment where a group will only contain one element and the group will be + re-created over and over as new upstream items trigger a new group. The behavior is + a trade-off between no-dataloss, upstream cancellation and excessive group creation. + +

        +
        Backpressure:
        +
        The consumer of the returned Flowable has to be ready to receive new GroupedFlowables or else + this operator will signal MissingBackpressureException. To avoid this exception, make + sure a combining operator (such as flatMap) has adequate amount of buffering/prefetch configured. + The inner GroupedFlowables honor backpressure but due to the single-source multiple consumer + nature of this operator, each group must be consumed so the whole operator can make progress and not hang.
        +
        Scheduler:
        +
        groupBy does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the upstream signals or the callback(s) throw an exception, the returned Flowable and + all active inner GroupedFlowables will signal the same exception.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        Parameters:
        +
        keySelector - a function that extracts the key for each item
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if keySelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: GroupBy, +groupBy(Function, boolean), +groupBy(Function, Function)
        +
        +
        • +
      + + + +
        +
      • +

        groupBy

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K> @NonNull Flowable<GroupedFlowable<K,T>> groupBy(@NonNull Function<? super T,? extends K> keySelector,
+        boolean delayError)
        +
        Groups the items emitted by the current Flowable according to a specified criterion, and emits these + grouped items as GroupedFlowables. The emitted GroupedFlowable allows only a single + Subscriber during its lifetime and if this Subscriber cancels before the + source terminates, the next emission by the source having the same key will trigger a new + GroupedFlowable emission. +

        + +

        + Note: A GroupedFlowable will cache the items it is to emit until such time as it + is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those + GroupedFlowables that do not concern you. Instead, you can signal to them that they may + discard their buffers by applying an operator like ignoreElements() to them. +

        + Note that the GroupedFlowables should be subscribed to as soon as possible, otherwise, + the unconsumed groups may starve other groups due to the internal backpressure + coordination of the groupBy operator. Such hangs can be usually avoided by using + flatMap(Function, int) or concatMapEager(Function, int, int) and overriding the default maximum concurrency + value to be greater or equal to the expected number of groups, possibly using + Integer.MAX_VALUE if the number of expected groups is unknown. +

        + Note also that ignoring groups or subscribing later (i.e., on another thread) will result in + so-called group abandonment where a group will only contain one element and the group will be + re-created over and over as new upstream items trigger a new group. The behavior is + a trade-off between no-dataloss, upstream cancellation and excessive group creation. + +

        +
        Backpressure:
        +
        The consumer of the returned Flowable has to be ready to receive new GroupedFlowables or else + this operator will signal MissingBackpressureException. To avoid this exception, make + sure a combining operator (such as flatMap) has adequate amount of buffering/prefetch configured. + The inner GroupedFlowables honor backpressure but due to the single-source multiple consumer + nature of this operator, each group must be consumed so the whole operator can make progress and not hang.
        +
        Scheduler:
        +
        groupBy does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the upstream signals or the callback(s) throw an exception, the returned Flowable and + all active inner GroupedFlowables will signal the same exception.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        Parameters:
        +
        keySelector - a function that extracts the key for each item
        +
        delayError - if true, the exception from the current Flowable is delayed in each group until that specific group emitted + the normal values; if false, the exception bypasses values in the groups and is reported immediately.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if keySelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: GroupBy
        +
        +
        • +
      + + + +
        +
      • +

        groupBy

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K,V> @NonNull Flowable<GroupedFlowable<K,V>> groupBy(@NonNull Function<? super T,? extends K> keySelector,
+        @NonNull Function<? super T,? extends V> valueSelector)
        +
        Groups the items emitted by the current Flowable according to a specified criterion, and emits these + grouped items as GroupedFlowables. The emitted GroupedFlowable allows only a single + Subscriber during its lifetime and if this Subscriber cancels before the + source terminates, the next emission by the source having the same key will trigger a new + GroupedFlowable emission. +

        + +

        + Note: A GroupedFlowable will cache the items it is to emit until such time as it + is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those + GroupedFlowables that do not concern you. Instead, you can signal to them that they may + discard their buffers by applying an operator like ignoreElements() to them. +

        + Note that the GroupedFlowables should be subscribed to as soon as possible, otherwise, + the unconsumed groups may starve other groups due to the internal backpressure + coordination of the groupBy operator. Such hangs can be usually avoided by using + flatMap(Function, int) or concatMapEager(Function, int, int) and overriding the default maximum concurrency + value to be greater or equal to the expected number of groups, possibly using + Integer.MAX_VALUE if the number of expected groups is unknown. +

        + Note also that ignoring groups or subscribing later (i.e., on another thread) will result in + so-called group abandonment where a group will only contain one element and the group will be + re-created over and over as new upstream items trigger a new group. The behavior is + a trade-off between no-dataloss, upstream cancellation and excessive group creation. + +

        +
        Backpressure:
        +
        The consumer of the returned Flowable has to be ready to receive new GroupedFlowables or else + this operator will signal MissingBackpressureException. To avoid this exception, make + sure a combining operator (such as flatMap) has adequate amount of buffering/prefetch configured. + The inner GroupedFlowables honor backpressure but due to the single-source multiple consumer + nature of this operator, each group must be consumed so the whole operator can make progress and not hang.
        +
        Scheduler:
        +
        groupBy does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the upstream signals or the callback(s) throw an exception, the returned Flowable and + all active inner GroupedFlowables will signal the same exception.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        V - the element type
        +
        Parameters:
        +
        keySelector - a function that extracts the key for each item
        +
        valueSelector - a function that extracts the return element for each item
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if keySelector or valueSelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: GroupBy, +groupBy(Function, Function, boolean), +groupBy(Function, Function, boolean, int), +groupBy(Function, Function, boolean, int, Function)
        +
        +
        • +
      + + + +
        +
      • +

        groupBy

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K,V> @NonNull Flowable<GroupedFlowable<K,V>> groupBy(@NonNull Function<? super T,? extends K> keySelector,
+        @NonNull Function<? super T,? extends V> valueSelector,
+        boolean delayError)
        +
        Groups the items emitted by the current Flowable according to a specified criterion, and emits these + grouped items as GroupedFlowables. The emitted GroupedFlowable allows only a single + Subscriber during its lifetime and if this Subscriber cancels before the + source terminates, the next emission by the source having the same key will trigger a new + GroupedFlowable emission. +

        + +

        + Note: A GroupedFlowable will cache the items it is to emit until such time as it + is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those + GroupedFlowables that do not concern you. Instead, you can signal to them that they may + discard their buffers by applying an operator like ignoreElements() to them. +

        + Note that the GroupedFlowables should be subscribed to as soon as possible, otherwise, + the unconsumed groups may starve other groups due to the internal backpressure + coordination of the groupBy operator. Such hangs can be usually avoided by using + flatMap(Function, int) or concatMapEager(Function, int, int) and overriding the default maximum concurrency + value to be greater or equal to the expected number of groups, possibly using + Integer.MAX_VALUE if the number of expected groups is unknown. +

        + Note also that ignoring groups or subscribing later (i.e., on another thread) will result in + so-called group abandonment where a group will only contain one element and the group will be + re-created over and over as new upstream items trigger a new group. The behavior is + a trade-off between no-dataloss, upstream cancellation and excessive group creation. + +

        +
        Backpressure:
        +
        The consumer of the returned Flowable has to be ready to receive new GroupedFlowables or else + this operator will signal MissingBackpressureException. To avoid this exception, make + sure a combining operator (such as flatMap) has adequate amount of buffering/prefetch configured. + The inner GroupedFlowables honor backpressure but due to the single-source multiple consumer + nature of this operator, each group must be consumed so the whole operator can make progress and not hang.
        +
        Scheduler:
        +
        groupBy does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the upstream signals or the callback(s) throw an exception, the returned Flowable and + all active inner GroupedFlowables will signal the same exception.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        V - the element type
        +
        Parameters:
        +
        keySelector - a function that extracts the key for each item
        +
        valueSelector - a function that extracts the return element for each item
        +
        delayError - if true, the exception from the current Flowable is delayed in each group until that specific group emitted + the normal values; if false, the exception bypasses values in the groups and is reported immediately.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if keySelector or valueSelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: GroupBy, +groupBy(Function, Function, boolean, int)
        +
        +
        • +
      + + + +
        +
      • +

        groupBy

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+public final <K,V> @NonNull Flowable<GroupedFlowable<K,V>> groupBy(@NonNull Function<? super T,? extends K> keySelector,
+        @NonNull Function<? super T,? extends V> valueSelector,
+        boolean delayError,
+        int bufferSize)
        +
        Groups the items emitted by the current Flowable according to a specified criterion, and emits these + grouped items as GroupedFlowables. The emitted GroupedFlowable allows only a single + Subscriber during its lifetime and if this Subscriber cancels before the + source terminates, the next emission by the source having the same key will trigger a new + GroupedFlowable emission. +

        + +

        + Note: A GroupedFlowable will cache the items it is to emit until such time as it + is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those + GroupedFlowables that do not concern you. Instead, you can signal to them that they may + discard their buffers by applying an operator like ignoreElements() to them. +

        + Note that the GroupedFlowables should be subscribed to as soon as possible, otherwise, + the unconsumed groups may starve other groups due to the internal backpressure + coordination of the groupBy operator. Such hangs can be usually avoided by using + flatMap(Function, int) or concatMapEager(Function, int, int) and overriding the default maximum concurrency + value to be greater or equal to the expected number of groups, possibly using + Integer.MAX_VALUE if the number of expected groups is unknown. +

        + Note also that ignoring groups or subscribing later (i.e., on another thread) will result in + so-called group abandonment where a group will only contain one element and the group will be + re-created over and over as new upstream items trigger a new group. The behavior is + a trade-off between no-dataloss, upstream cancellation and excessive group creation. + +

        +
        Backpressure:
        +
        The consumer of the returned Flowable has to be ready to receive new GroupedFlowables or else + this operator will signal MissingBackpressureException. To avoid this exception, make + sure a combining operator (such as flatMap) has adequate amount of buffering/prefetch configured. + The inner GroupedFlowables honor backpressure but due to the single-source multiple consumer + nature of this operator, each group must be consumed so the whole operator can make progress and not hang.
        +
        Scheduler:
        +
        groupBy does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the upstream signals or the callback(s) throw an exception, the returned Flowable and + all active inner GroupedFlowables will signal the same exception.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        V - the element type
        +
        Parameters:
        +
        keySelector - a function that extracts the key for each item
        +
        valueSelector - a function that extracts the return element for each item
        +
        delayError - if true, the exception from the current Flowable is delayed in each group until that specific group emitted + the normal values; if false, the exception bypasses values in the groups and is reported immediately.
        +
        bufferSize - the hint for how many GroupedFlowables and element in each GroupedFlowable should be buffered
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if keySelector or valueSelector is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: GroupBy
        +
        +
        • +
      + + + +
        +
      • +

        groupBy

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+public final <K,V> @NonNull Flowable<GroupedFlowable<K,V>> groupBy(@NonNull Function<? super T,? extends K> keySelector,
+        @NonNull Function<? super T,? extends V> valueSelector,
+        boolean delayError,
+        int bufferSize,
+        @NonNull Function<? super Consumer<Object>,? extends Map<K,Object>> evictingMapFactory)
        +
        Groups the items emitted by the current Flowable according to a specified criterion, and emits these + grouped items as GroupedFlowables. The emitted GroupedFlowable allows only a single + Subscriber during its lifetime and if this Subscriber cancels before the + source terminates, the next emission by the source having the same key will trigger a new + GroupedFlowable emission. The evictingMapFactory is used to create a map that will + be used to hold the GroupedFlowables by key. The evicting map created by this factory must + notify the provided Consumer<Object> with the entry value (not the key!) when an entry in this + map has been evicted. The next source emission will bring about the completion of the evicted + GroupedFlowables and the arrival of an item with the same key as a completed GroupedFlowable + will prompt the creation and emission of a new GroupedFlowable with that key. + +

        A use case for specifying an evictingMapFactory is where the source is infinite and fast and + over time the number of keys grows enough to be a concern in terms of the memory footprint of the + internal hash map containing the GroupedFlowables. + +

        The map created by an evictingMapFactory must be thread-safe. + +

        An example of an evictingMapFactory using CacheBuilder from the Guava library is below: + + 

        
+ Function<Consumer<Object>, Map<Integer, Object>> evictingMapFactory =
+   notify ->
+       CacheBuilder
+         .newBuilder()
+         .maximumSize(3)
+         .removalListener(entry -> {
+              try {
+                  // emit the value not the key!
+                  notify.accept(entry.getValue());
+              } catch (Exception e) {
+                  throw new RuntimeException(e);
+              }
+            })
+         .<Integer, Object> build()
+         .asMap();
+
+ // Emit 1000 items but ensure that the
+ // internal map never has more than 3 items in it
+   Flowable
+   .range(1, 1000)
+   // note that number of keys is 10
+   .groupBy(x -> x % 10, x -> x, true, 16, evictingMapFactory)
+   .flatMap(g -> g)
+   .forEach(System.out::println);
+
        + +

        + +

        + Note: A GroupedFlowable will cache the items it is to emit until such time as it + is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those + GroupedFlowables that do not concern you. Instead, you can signal to them that they may + discard their buffers by applying an operator like ignoreElements() to them. +

        + Note that the GroupedFlowables should be subscribed to as soon as possible, otherwise, + the unconsumed groups may starve other groups due to the internal backpressure + coordination of the groupBy operator. Such hangs can be usually avoided by using + flatMap(Function, int) or concatMapEager(Function, int, int) and overriding the default maximum concurrency + value to be greater or equal to the expected number of groups, possibly using + Integer.MAX_VALUE if the number of expected groups is unknown. +

        + Note also that ignoring groups or subscribing later (i.e., on another thread) will result in + so-called group abandonment where a group will only contain one element and the group will be + re-created over and over as new upstream items trigger a new group. The behavior is + a trade-off between no-dataloss, upstream cancellation and excessive group creation. + +

        +
        Backpressure:
        +
        The consumer of the returned Flowable has to be ready to receive new GroupedFlowables or else + this operator will signal MissingBackpressureException. To avoid this exception, make + sure a combining operator (such as flatMap) has adequate amount of buffering/prefetch configured. + The inner GroupedFlowables honor backpressure but due to the single-source multiple consumer + nature of this operator, each group must be consumed so the whole operator can make progress and not hang.
        +
        Scheduler:
        +
        groupBy does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the upstream signals or the callback(s) throw an exception, the returned Flowable and + all active inner GroupedFlowables will signal the same exception.
        +
        +

        History: 2.1.10 - beta

        +
        +
        Type Parameters:
        +
        K - the key type
        +
        V - the element type
        +
        Parameters:
        +
        keySelector - a function that extracts the key for each item
        +
        valueSelector - a function that extracts the return element for each item
        +
        delayError - if true, the exception from the current Flowable is delayed in each group until that specific group emitted + the normal values; if false, the exception bypasses values in the groups and is reported immediately.
        +
        bufferSize - the hint for how many GroupedFlowables and element in each GroupedFlowable should be buffered
        +
        evictingMapFactory - The factory used to create a map that will be used by the implementation to hold the + GroupedFlowables. The evicting map created by this factory must + notify the provided Consumer<Object> with the entry value (not the key!) when + an entry in this map has been evicted. The next source emission will bring about the + completion of the evicted GroupedFlowables. See example above.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if keySelector, valueSelector or evictingMapFactory is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        ReactiveX operators documentation: GroupBy
        +
        +
        • +
      + + + +
        +
      • +

        groupJoin

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+public final <TRight,TLeftEnd,TRightEnd,R> @NonNull Flowable<R> groupJoin(@NonNull Publisher<? extends TRight> other,
+        @NonNull Function<? super T,? extends Publisher<TLeftEnd>> leftEnd,
+        @NonNull Function<? super TRight,? extends Publisher<TRightEnd>> rightEnd,
+        @NonNull BiFunction<? super T,? super Flowable<TRight>,? extends R> resultSelector)
        +
        Returns a Flowable that correlates two Publishers when they overlap in time and groups the results. +

        + There are no guarantees in what order the items get combined when multiple + items from one or both source Publishers overlap. +

        + +

        +
        Backpressure:
        +
        The operator doesn't support backpressure and consumes all participating Publishers in + an unbounded mode (i.e., not applying any backpressure to them).
        +
        Scheduler:
        +
        groupJoin does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        TRight - the value type of the right Publisher source
        +
        TLeftEnd - the element type of the left duration Publishers
        +
        TRightEnd - the element type of the right duration Publishers
        +
        R - the result type
        +
        Parameters:
        +
        other - the other Publisher to correlate items from the current Flowable with
        +
        leftEnd - a function that returns a Publisher whose emissions indicate the duration of the values of + the current Flowable
        +
        rightEnd - a function that returns a Publisher whose emissions indicate the duration of the values of + the right Publisher
        +
        resultSelector - a function that takes an item emitted by each Publisher and returns the value to be emitted + by the resulting Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if other, leftEnd, rightEnd or resultSelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: Join
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        join

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+public final <TRight,TLeftEnd,TRightEnd,R> @NonNull Flowable<R> join(@NonNull Publisher<? extends TRight> other,
+        @NonNull Function<? super T,? extends Publisher<TLeftEnd>> leftEnd,
+        @NonNull Function<? super TRight,? extends Publisher<TRightEnd>> rightEnd,
+        @NonNull BiFunction<? super T,? super TRight,? extends R> resultSelector)
        +
        Correlates the items emitted by two Publishers based on overlapping durations. +

        + There are no guarantees in what order the items get combined when multiple + items from one or both source Publishers overlap. +

        + +

        +
        Backpressure:
        +
        The operator doesn't support backpressure and consumes all participating Publishers in + an unbounded mode (i.e., not applying any backpressure to them).
        +
        Scheduler:
        +
        join does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        TRight - the value type of the right Publisher source
        +
        TLeftEnd - the element type of the left duration Publishers
        +
        TRightEnd - the element type of the right duration Publishers
        +
        R - the result type
        +
        Parameters:
        +
        other - the second Publisher to join items from
        +
        leftEnd - a function to select a duration for each item emitted by the current Flowable, used to + determine overlap
        +
        rightEnd - a function to select a duration for each item emitted by the right Publisher, used to + determine overlap
        +
        resultSelector - a function that computes an item to be emitted by the resulting Flowable for any two + overlapping items emitted by the two Publishers
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if other, leftEnd, rightEnd or resultSelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: Join
        +
        +
        • +
      + + + + + + + + + + + + + + + + + +
        +
      • +

        lift

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> lift(@NonNull FlowableOperator<? extends R,? super T> lifter)
        +
        This method requires advanced knowledge about building operators, please consider + other standard composition methods first; + Returns a Flowable which, when subscribed to, invokes the apply(Subscriber) method + of the provided FlowableOperator for each individual downstream Subscriber and allows the + insertion of a custom operator by accessing the downstream's Subscriber during this subscription phase + and providing a new Subscriber, containing the custom operator's intended business logic, that will be + used in the subscription process going further upstream. +

        + Generally, such a new Subscriber will wrap the downstream's Subscriber and forwards the + onNext, onError and onComplete events from the upstream directly or according to the + emission pattern the custom operator's business logic requires. In addition, such operator can intercept the + flow control calls of cancel and request that would have traveled upstream and perform + additional actions depending on the same business logic requirements. +

        + Example: + 

        
+ // Step 1: Create the consumer type that will be returned by the FlowableOperator.apply():
+
+ public final class CustomSubscriber<T> implements FlowableSubscriber<T>, Subscription {
+
+     // The downstream's Subscriber that will receive the onXXX events
+     final Subscriber<? super String> downstream;
+
+     // The connection to the upstream source that will call this class' onXXX methods
+     Subscription upstream;
+
+     // The constructor takes the downstream subscriber and usually any other parameters
+     public CustomSubscriber(Subscriber<? super String> downstream) {
+         this.downstream = downstream;
+     }
+
+     // In the subscription phase, the upstream sends a Subscription to this class
+     // and subsequently this class has to send a Subscription to the downstream.
+     // Note that relaying the upstream's Subscription instance directly is not allowed in RxJava
+     @Override
+     public void onSubscribe(Subscription s) {
+         if (upstream != null) {
+             s.cancel();
+         } else {
+             upstream = s;
+             downstream.onSubscribe(this);
+         }
+     }
+
+     // The upstream calls this with the next item and the implementation's
+     // responsibility is to emit an item to the downstream based on the intended
+     // business logic, or if it can't do so for the particular item,
+        // request more from the upstream
+     @Override
+     public void onNext(T item) {
+         String str = item.toString();
+         if (str.length() < 2) {
+             downstream.onNext(str);
+         } else {
+             upstream.request(1);
+         }
+     }
+
+     // Some operators may handle the upstream's error while others
+     // could just forward it to the downstream.
+     @Override
+     public void onError(Throwable throwable) {
+         downstream.onError(throwable);
+     }
+
+     // When the upstream completes, usually the downstream should complete as well.
+     @Override
+     public void onComplete() {
+         downstream.onComplete();
+     }
+
+     // Some operators have to intercept the downstream's request calls to trigger
+     // the emission of queued items while others can simply forward the request
+     // amount as is.
+     @Override
+     public void request(long n) {
+         upstream.request(n);
+     }
+
+     // Some operators may use their own resources which should be cleaned up if
+     // the downstream cancels the flow before it completed. Operators without
+     // resources can simply forward the cancellation to the upstream.
+     // In some cases, a canceled flag may be set by this method so that other parts
+     // of this class may detect the cancellation and stop sending events
+     // to the downstream.
+     @Override
+     public void cancel() {
+         upstream.cancel();
+     }
+ }
+
+ // Step 2: Create a class that implements the FlowableOperator interface and
+ //         returns the custom consumer type from above in its apply() method.
+ //         Such class may define additional parameters to be submitted to
+ //         the custom consumer type.
+
+ final class CustomOperator<T> implements FlowableOperator<String> {
+     @Override
+     public Subscriber<? super String> apply(Subscriber<? super T> upstream) {
+         return new CustomSubscriber<T>(upstream);
+     }
+ }
+
+ // Step 3: Apply the custom operator via lift() in a flow by creating an instance of it
+ //         or reusing an existing one.
+
+ Flowable.range(5, 10)
+ .lift(new CustomOperator<Integer>())
+ .test()
+ .assertResult("5", "6", "7", "8", "9");
+
        +

        + Creating custom operators can be complicated and it is recommended one consults the + RxJava wiki: Writing operators page about + the tools, requirements, rules, considerations and pitfalls of implementing them. +

        + Note that implementing custom operators via this lift() method adds slightly more overhead by requiring + an additional allocation and indirection per assembled flows. Instead, extending the abstract Flowable + class and creating a FlowableTransformer with it is recommended. +

        + Note also that it is not possible to stop the subscription phase in lift() as the apply() method + requires a non-null Subscriber instance to be returned, which is then unconditionally subscribed to + the upstream Flowable. For example, if the operator decided there is no reason to subscribe to the + upstream source because of some optimization possibility or a failure to prepare the operator, it still has to + return a Subscriber that should immediately cancel the upstream's Subscription in its + onSubscribe method. Again, using a FlowableTransformer and extending the Flowable is + a better option as subscribeActual(org.reactivestreams.Subscriber<? super T>) can decide to not subscribe to its upstream after all. +

        +
        Backpressure:
        +
        The Subscriber instance returned by the FlowableOperator is responsible to be + backpressure-aware or document the fact that the consumer of the returned Publisher has to apply one of + the onBackpressureXXX operators.
        +
        Scheduler:
        +
        lift does not operate by default on a particular Scheduler, however, the + FlowableOperator may use a Scheduler to support its own asynchronous behavior.
        +
        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        lifter - the FlowableOperator that receives the downstream's Subscriber and should return + a Subscriber with custom behavior to be used as the consumer for the current + Flowable.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if lifter is null
        +
        See Also:
        +
        RxJava wiki: Writing operators, +compose(FlowableTransformer)
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        mergeWith

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> mergeWith(@NonNull SingleSource<? extends T> other)
        +
        Merges the sequence of items of this Flowable with the success value of the other SingleSource. +

        + +

        + The success value of the other SingleSource can get interleaved at any point of this + Flowable sequence. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and ensures the success item from the + SingleSource is emitted only when there is a downstream demand.
        +
        Scheduler:
        +
        mergeWith does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.10 - experimental

        +
        +
        Parameters:
        +
        other - the SingleSource whose success value to merge with
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if other is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        mergeWith

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> mergeWith(@NonNull MaybeSource<? extends T> other)
        +
        Merges the sequence of items of this Flowable with the success value of the other MaybeSource + or waits for both to complete normally if the MaybeSource is empty. +

        + +

        + The success value of the other MaybeSource can get interleaved at any point of this + Flowable sequence. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and ensures the success item from the + MaybeSource is emitted only when there is a downstream demand.
        +
        Scheduler:
        +
        mergeWith does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.10 - experimental

        +
        +
        Parameters:
        +
        other - the MaybeSource which provides a success value to merge with or completes
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if other is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        onBackpressureBuffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> onBackpressureBuffer(boolean delayError)
        +
        Buffers an unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place, optionally delaying an error until all buffered items have been consumed. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an unbounded + manner (i.e., not applying backpressure to it).
        +
        Scheduler:
        +
        onBackpressureBuffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        delayError - if true, an exception from the current Flowable is delayed until all buffered elements have been + consumed by the downstream; if false, an exception is immediately signaled to the downstream, skipping + any buffered element
        +
        Returns:
        +
        the new Flowable instance
        +
        See Also:
        +
        ReactiveX operators documentation: backpressure operators
        +
        +
        • +
      + + + + + + + +
        +
      • +

        onBackpressureBuffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> onBackpressureBuffer(int capacity,
+        boolean delayError)
        +
        Buffers an limited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place, however, the resulting Flowable will signal a + MissingBackpressureException via onError as soon as the buffer's capacity is exceeded, dropping all undelivered + items, and canceling the flow. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an unbounded + manner (i.e., not applying backpressure to it).
        +
        Scheduler:
        +
        onBackpressureBuffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        capacity - number of slots available in the buffer.
        +
        delayError - if true, an exception from the current Flowable is delayed until all buffered elements have been + consumed by the downstream; if false, an exception is immediately signaled to the downstream, skipping + any buffered element
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if capacity is non-positive
        +
        Since:
        +
        1.1.0
        +
        See Also:
        +
        ReactiveX operators documentation: backpressure operators
        +
        +
        • +
      + + + +
        +
      • +

        onBackpressureBuffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> onBackpressureBuffer(int capacity,
+        boolean delayError,
+        boolean unbounded)
        +
        Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place. + If unbounded is true, the resulting Flowable will signal a + MissingBackpressureException via onError as soon as the buffer's capacity is exceeded, dropping all undelivered + items, and canceling the flow. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an unbounded + manner (i.e., not applying backpressure to it).
        +
        Scheduler:
        +
        onBackpressureBuffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        capacity - number of slots available in the buffer.
        +
        delayError - if true, an exception from the current Flowable is delayed until all buffered elements have been + consumed by the downstream; if false, an exception is immediately signaled to the downstream, skipping + any buffered element
        +
        unbounded - if true, the capacity value is interpreted as the internal "island" size of the unbounded buffer
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if capacity is non-positive
        +
        Since:
        +
        1.1.0
        +
        See Also:
        +
        ReactiveX operators documentation: backpressure operators
        +
        +
        • +
      + + + +
        +
      • +

        onBackpressureBuffer

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> onBackpressureBuffer(int capacity,
+        boolean delayError,
+        boolean unbounded,
+        @NonNull Action onOverflow)
        +
        Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place. + If unbounded is true, the resulting Flowable will signal a + MissingBackpressureException via onError as soon as the buffer's capacity is exceeded, dropping all undelivered + items, canceling the flow and calling the onOverflow action. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an unbounded + manner (i.e., not applying backpressure to it).
        +
        Scheduler:
        +
        onBackpressureBuffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        capacity - number of slots available in the buffer.
        +
        delayError - if true, an exception from the current Flowable is delayed until all buffered elements have been + consumed by the downstream; if false, an exception is immediately signaled to the downstream, skipping + any buffered element
        +
        unbounded - if true, the capacity value is interpreted as the internal "island" size of the unbounded buffer
        +
        onOverflow - action to execute if an item needs to be buffered, but there are no available slots.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if onOverflow is null
        +
        IllegalArgumentException - if capacity is non-positive
        +
        Since:
        +
        1.1.0
        +
        See Also:
        +
        ReactiveX operators documentation: backpressure operators, +onBackpressureBuffer(int, boolean, boolean, Action, Consumer)
        +
        +
        • +
      + + + +
        +
      • +

        onBackpressureBuffer

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> onBackpressureBuffer(int capacity,
+        boolean delayError,
+        boolean unbounded,
+        @NonNull Action onOverflow,
+        @NonNull Consumer<? super T> onDropped)
        +
        Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place. + If unbounded is true, the resulting Flowable will signal a + MissingBackpressureException via onError as soon as the buffer's capacity is exceeded, dropping all undelivered + items, canceling the flow and calling the onOverflow action. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an unbounded + manner (i.e., not applying backpressure to it).
        +
        Scheduler:
        +
        onBackpressureBuffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        capacity - number of slots available in the buffer.
        +
        delayError - if true, an exception from the current Flowable is delayed until all buffered elements have been + consumed by the downstream; if false, an exception is immediately signaled to the downstream, skipping + any buffered element
        +
        unbounded - if true, the capacity value is interpreted as the internal "island" size of the unbounded buffer
        +
        onOverflow - action to execute if an item needs to be buffered, but there are no available slots.
        +
        onDropped - the Consumer to be called with the item that could not be buffered due to capacity constraints.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if onOverflow or onDropped is null
        +
        IllegalArgumentException - if capacity is non-positive
        +
        Since:
        +
        3.1.7
        +
        See Also:
        +
        ReactiveX operators documentation: backpressure operators
        +
        +
        • +
      + + + +
        +
      • +

        onBackpressureBuffer

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> onBackpressureBuffer(int capacity,
+        @NonNull Action onOverflow)
        +
        Buffers an limited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place, however, the resulting Flowable will signal a + MissingBackpressureException via onError as soon as the buffer's capacity is exceeded, dropping all undelivered + items, canceling the flow and calling the onOverflow action. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an unbounded + manner (i.e., not applying backpressure to it).
        +
        Scheduler:
        +
        onBackpressureBuffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        capacity - number of slots available in the buffer.
        +
        onOverflow - action to execute if an item needs to be buffered, but there are no available slots. Null is allowed.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if onOverflow is null
        +
        IllegalArgumentException - if capacity is non-positive
        +
        Since:
        +
        1.1.0
        +
        See Also:
        +
        ReactiveX operators documentation: backpressure operators
        +
        +
        • +
      + + + + + + + +
        +
      • +

        onBackpressureBuffer

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> onBackpressureBuffer(long capacity,
+        @Nullable Action onOverflow,
+        @NonNull BackpressureOverflowStrategy overflowStrategy,
+        @NonNull Consumer<? super T> onDropped)
        +
        Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the + downstream to consume the items at its own place. + The resulting Flowable will behave as determined by overflowStrategy if the buffer capacity is exceeded: +
          +
        • BackpressureOverflowStrategy.ERROR (default) will call onError dropping all undelivered items, + canceling the source, and notifying the producer with onOverflow.
          • +
        • BackpressureOverflowStrategy.DROP_LATEST will drop any new items emitted by the producer while + the buffer is full, without generating any onError. Each drop will, however, invoke onOverflow + to signal the overflow to the producer.
          • +
        • BackpressureOverflowStrategy.DROP_OLDEST will drop the oldest items in the buffer in order to make + room for newly emitted ones. Overflow will not generate an onError, but each drop will invoke + onOverflow to signal the overflow to the producer.
          • +
        + +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an unbounded + manner (i.e., not applying backpressure to it).
        +
        Scheduler:
        +
        onBackpressureBuffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        capacity - number of slots available in the buffer.
        +
        onOverflow - action to execute if an item needs to be buffered, but there are no available slots, null is allowed.
        +
        overflowStrategy - how should the resulting Flowable react to buffer overflows, null is not allowed.
        +
        onDropped - the Consumer to be called with the item that could not be buffered due to capacity constraints.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if onOverflow, overflowStrategy or onDropped is null
        +
        IllegalArgumentException - if capacity is non-positive
        +
        Since:
        +
        3.1.7
        +
        See Also:
        +
        ReactiveX operators documentation: backpressure operators
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        onBackpressureLatest

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> onBackpressureLatest()
        +
        Drops all but the latest item emitted by the current Flowable if the downstream is not ready to receive + new items (indicated by a lack of Subscription.request(long) calls from it) and emits this latest + item when the downstream becomes ready. +

        + +

        + Its behavior is logically equivalent to blockingLatest() with the exception that + the downstream is not blocking while requesting more values. +

        + Note that if the current Flowable does support backpressure, this operator ignores that capability + and doesn't propagate any backpressure requests from downstream. +

        + Note that due to the nature of how backpressure requests are propagated through subscribeOn/observeOn, + requesting more than 1 from downstream doesn't guarantee a continuous delivery of onNext events. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an unbounded + manner (i.e., not applying backpressure to it).
        +
        Scheduler:
        +
        onBackpressureLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Flowable instance
        +
        Since:
        +
        1.1.0
        +
        +
        • +
      + + + +
        +
      • +

        onBackpressureLatest

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> onBackpressureLatest(@NonNull Consumer<? super T> onDropped)
        +
        Drops all but the latest item emitted by the current Flowable if the downstream is not ready to receive + new items (indicated by a lack of Subscription.request(long) calls from it) and emits this latest + item when the downstream becomes ready. +

        + +

        + Its behavior is logically equivalent to blockingLatest() with the exception that + the downstream is not blocking while requesting more values. +

        + Note that if the current Flowable does support backpressure, this operator ignores that capability + and doesn't propagate any backpressure requests from downstream. +

        + Note that due to the nature of how backpressure requests are propagated through subscribeOn/observeOn, + requesting more than 1 from downstream doesn't guarantee a continuous delivery of onNext events. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an unbounded + manner (i.e., not applying backpressure to it).
        +
        Scheduler:
        +
        onBackpressureLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        onDropped - called with the current entry when it has been replaced by a new one
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if onDropped is null
        +
        Since:
        +
        3.1.7
        +
        +
        • +
      + + + +
        +
      • +

        onBackpressureReduce

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> onBackpressureReduce(@NonNull BiFunction<T,T,T> reducer)
        +
        Reduces a sequence of two not emitted values via a function into a single value if the downstream is not ready to receive + new items (indicated by a lack of Subscription.request(long) calls from it) and emits this latest + item when the downstream becomes ready. +

        + +

        + Note that if the current Flowable does support backpressure, this operator ignores that capability + and doesn't propagate any backpressure requests from downstream. +

        + Note that due to the nature of how backpressure requests are propagated through subscribeOn/observeOn, + requesting more than 1 from downstream doesn't guarantee a continuous delivery of onNext events. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an unbounded + manner (i.e., not applying backpressure to it).
        +
        Scheduler:
        +
        onBackpressureReduce does not operate by default on a particular Scheduler.
        +
        +

        History: 3.0.9 - experimental

        +
        +
        Parameters:
        +
        reducer - the bi-function to call when there is more than one non-emitted value to downstream, + the first argument of the bi-function is previous item and the second one is currently + emitting from upstream
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if reducer is null
        +
        Since:
        +
        3.1.0
        +
        See Also:
        +
        onBackpressureReduce(Supplier, BiFunction)
        +
        +
        • +
      + + + +
        +
      • +

        onBackpressureReduce

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> onBackpressureReduce(@NonNull Supplier<R> supplier,
+        @NonNull BiFunction<R,? super T,R> reducer)
        +
        Reduces upstream values into an aggregate value, provided by a supplier and combined via a reducer function, + while the downstream is not ready to receive items, then emits this aggregate value when the downstream becomes ready. +

        + +

        + Note that even if the downstream is ready to receive an item, the upstream item will always be aggregated into the output type, + calling both the supplier and the reducer to produce the output value. +

        + Note that if the current Flowable does support backpressure, this operator ignores that capability + and doesn't propagate any backpressure requests from downstream. +

        + Note that due to the nature of how backpressure requests are propagated through subscribeOn/observeOn, + requesting more than 1 from downstream doesn't guarantee a continuous delivery of onNext events. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an unbounded + manner (i.e., not applying backpressure to it).
        +
        Scheduler:
        +
        onBackpressureReduce does not operate by default on a particular Scheduler.
        +
        +

        History: 3.0.9 - experimental

        +
        +
        Type Parameters:
        +
        R - the aggregate type emitted when the downstream requests more items
        +
        Parameters:
        +
        supplier - the factory to call to create new item of type R to pass it as the first argument to reducer. + It is called when previous returned value by reducer already sent to + downstream or the very first update from upstream received.
        +
        reducer - the bi-function to call to reduce excessive updates which downstream is not ready to receive. + The first argument of type R is the object returned by supplier or result of previous + reducer invocation. The second argument of type T is the current update from upstream.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if supplier or reducer is null
        +
        Since:
        +
        3.1.0
        +
        See Also:
        +
        onBackpressureReduce(BiFunction)
        +
        +
        • +
      + + + +
        +
      • +

        onErrorComplete

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=PASS_THROUGH)
+ @NonNull
+public final @NonNull Flowable<T> onErrorComplete()
        +
        Returns a Flowable instance that if the current Flowable emits an error, it will emit an onComplete + and swallow the throwable. +

        + +

        +
        Backpressure:
        +
        The operator doesn't interfere with backpressure which is determined by the current Flowable's backpressure + behavior.
        +
        Scheduler:
        +
        onErrorComplete does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Flowable instance
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        onErrorComplete

        +
        @CheckReturnValue
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> onErrorComplete(@NonNull Predicate<? super Throwable> predicate)
        +
        Returns a Flowable instance that if the current Flowable emits an error and the predicate returns + true, it will emit an onComplete and swallow the throwable. +

        + +

        +
        Backpressure:
        +
        The operator doesn't interfere with backpressure which is determined by the current Flowable's backpressure + behavior.
        +
        Scheduler:
        +
        onErrorComplete does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        predicate - the predicate to call when an Throwable is emitted which should return true + if the Throwable should be swallowed and replaced with an onComplete.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if predicate is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        onErrorResumeNext

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> onErrorResumeNext(@NonNull Function<? super Throwable,? extends Publisher<? extends T>> fallbackSupplier)
        +
        Resumes the flow with a Publisher returned for the failure Throwable of the current Flowable by a + function instead of signaling the error via onError. +

        + +

        + By default, when a Publisher encounters an error that prevents it from emitting the expected item to + its Subscriber, the Publisher invokes its Subscriber's onError method, and then quits + without invoking any more of its Subscriber's methods. The onErrorResumeNext method changes this + behavior. If you pass a function that returns a Publisher (resumeFunction) to + onErrorResumeNext, if the original Publisher encounters an error, instead of invoking its + Subscriber's onError method, it will instead relinquish control to the Publisher returned from + resumeFunction, which will invoke the Subscriber's onNext method if it is + able to do so. In such a case, because no Publisher necessarily invokes onError, the Subscriber + may never know that an error happened. +

        + You can use this to prevent errors from propagating or to supply fallback data should errors be + encountered. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. This and the resuming Publishers + are expected to honor backpressure as well. + If any of them violate this expectation, the operator may throw an + IllegalStateException when the current Flowable completes or + a MissingBackpressureException is signaled somewhere downstream.
        +
        Scheduler:
        +
        onErrorResumeNext does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        fallbackSupplier - a function that returns a Publisher that will take over if the current Flowable encounters + an error
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if fallbackSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: Catch
        +
        +
        • +
      + + + +
        +
      • +

        onErrorResumeWith

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> onErrorResumeWith(@NonNull Publisher<? extends T> fallback)
        +
        Resumes the flow with the given Publisher when the current Flowable fails instead of + signaling the error via onError. +

        + +

        + By default, when a Publisher encounters an error that prevents it from emitting the expected item to + its Subscriber, the Publisher invokes its Subscriber's onError method, and then quits + without invoking any more of its Subscriber's methods. The onErrorResumeWith method changes this + behavior. If you pass another Publisher (resumeSequence) to a Publisher's + onErrorResumeWith method, if the original Publisher encounters an error, instead of invoking its + Subscriber's onError method, it will instead relinquish control to resumeSequence which + will invoke the Subscriber's onNext method if it is able to do so. In such a case, + because no Publisher necessarily invokes onError, the Subscriber may never know that an error + happened. +

        + You can use this to prevent errors from propagating or to supply fallback data should errors be + encountered. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. This and the resuming Publishers + are expected to honor backpressure as well. + If any of them violate this expectation, the operator may throw an + IllegalStateException when the current Flowable completes or + MissingBackpressureException is signaled somewhere downstream.
        +
        Scheduler:
        +
        onErrorResumeWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        fallback - the next Publisher source that will take over if the current Flowable encounters + an error
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if fallback is null
        +
        See Also:
        +
        ReactiveX operators documentation: Catch
        +
        +
        • +
      + + + +
        +
      • +

        onErrorReturn

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> onErrorReturn(@NonNull Function<? super Throwable,? extends T> itemSupplier)
        +
        Ends the flow with a last item returned by a function for the Throwable error signaled by the current + Flowable instead of signaling the error via onError. +

        + +

        + By default, when a Publisher encounters an error that prevents it from emitting the expected item to + its Subscriber, the Publisher invokes its Subscriber's onError method, and then quits + without invoking any more of its Subscriber's methods. The onErrorReturn method changes this + behavior. If you pass a function (resumeFunction) to a Publisher's onErrorReturn + method, if the original Publisher encounters an error, instead of invoking its Subscriber's + onError method, it will instead emit the return value of resumeFunction. +

        + You can use this to prevent errors from propagating or to supply fallback data should errors be + encountered. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The current Flowable is expected to honor + backpressure as well. If it this expectation is violated, the operator may throw + IllegalStateException when the current Flowable completes or + MissingBackpressureException is signaled somewhere downstream.
        +
        Scheduler:
        +
        onErrorReturn does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        itemSupplier - a function that returns a single value that will be emitted along with a regular onComplete in case + the current Flowable signals an onError event
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if itemSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: Catch
        +
        +
        • +
      + + + + + +
        +
      • +

        onErrorReturnItem

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> onErrorReturnItem(@NonNull T item)
        +
        Ends the flow with the given last item when the current Flowable fails instead of signaling the error via onError. +

        + +

        + By default, when a Publisher encounters an error that prevents it from emitting the expected item to + its Subscriber, the Publisher invokes its Subscriber's onError method, and then quits + without invoking any more of its Subscriber's methods. The onErrorReturn method changes this + behavior. If you pass a function (resumeFunction) to a Publisher's onErrorReturn + method, if the original Publisher encounters an error, instead of invoking its Subscriber's + onError method, it will instead emit the return value of resumeFunction. +

        + You can use this to prevent errors from propagating or to supply fallback data should errors be + encountered. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The current Flowable is expected to honor + backpressure as well. If it this expectation is violated, the operator may throw + IllegalStateException when the current Flowable completes or + MissingBackpressureException is signaled somewhere downstream.
        +
        Scheduler:
        +
        onErrorReturnItem does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        item - the value that is emitted along with a regular onComplete in case the current + Flowable signals an exception
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if item is null
        +
        See Also:
        +
        ReactiveX operators documentation: Catch
        +
        +
        • +
      + + + +
        +
      • +

        onTerminateDetach

        +
        @CheckReturnValue
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> onTerminateDetach()
        +
        Nulls out references to the upstream producer and downstream Subscriber if + the sequence is terminated or downstream cancels. +
        +
        Backpressure:
        +
        The operator doesn't interfere with backpressure which is determined by the current Flowable's backpressure + behavior.
        +
        Scheduler:
        +
        onTerminateDetach does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Flowable instance + the sequence is terminated or downstream cancels
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        parallel

        +
        @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @CheckReturnValue
+ @NonNull
+public final @NonNull ParallelFlowable<T> parallel(int parallelism,
+        int prefetch)
        +
        Parallelizes the flow by creating the specified number of 'rails' + and dispatches the upstream items to them in a round-robin fashion and + uses the defined per-'rail' prefetch amount. +

        + Note that the rails don't execute in parallel on their own and one needs to + apply ParallelFlowable.runOn(Scheduler) to specify the Scheduler where + each rail will execute. +

        + To merge the parallel 'rails' back into a single sequence, use ParallelFlowable.sequential(). +

        + +

        +
        Backpressure:
        +
        The operator requires the upstream to honor backpressure and each 'rail' honors backpressure + as well.
        +
        Scheduler:
        +
        parallel does not operate by default on a particular Scheduler.
        +
        +

        History: 2.0.5 - experimental; 2.1 - beta

        +
        +
        Parameters:
        +
        parallelism - the number of 'rails' to use
        +
        prefetch - the number of items each 'rail' should prefetch
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        IllegalArgumentException - if parallelism or prefetch is non-positive
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + + + + + +
        +
      • +

        publish

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> publish(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector)
        +
        Returns a Flowable that emits the results of invoking a specified selector on items emitted by a + ConnectableFlowable that shares a single subscription to the underlying sequence. +

        + +

        +
        Backpressure:
        +
        The operator expects the current Flowable to honor backpressure and if this expectation is + violated, the operator will signal a MissingBackpressureException through the Flowable + provided to the function. Since the Publisher returned by the selector may be + independent of the provided Flowable to the function, the output's backpressure behavior + is determined by this returned Publisher.
        +
        Scheduler:
        +
        publish does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Flowable
        +
        Parameters:
        +
        selector - a function that can use the multicasted source sequence as many times as needed, without + causing multiple subscriptions to the source sequence. Subscribers to the given source will + receive all notifications of the source from the time of the subscription forward.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if selector is null
        +
        See Also:
        +
        ReactiveX operators documentation: Publish
        +
        +
        • +
      + + + +
        +
      • +

        publish

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> publish(@NonNull Function<? super Flowable<T>,? extends Publisher<? extends R>> selector,
+        int prefetch)
        +
        Returns a Flowable that emits the results of invoking a specified selector on items emitted by a + ConnectableFlowable that shares a single subscription to the underlying sequence. +

        + +

        +
        Backpressure:
        +
        The operator expects the current Flowable to honor backpressure and if this expectation is + violated, the operator will signal a MissingBackpressureException through the Flowable + provided to the function. Since the Publisher returned by the selector may be + independent of the provided Flowable to the function, the output's backpressure behavior + is determined by this returned Publisher.
        +
        Scheduler:
        +
        publish does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Flowable
        +
        Parameters:
        +
        selector - a function that can use the multicasted source sequence as many times as needed, without + causing multiple subscriptions to the source sequence. Subscribers to the given source will + receive all notifications of the source from the time of the subscription forward.
        +
        prefetch - the number of elements to prefetch from the current Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if selector is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Publish
        +
        +
        • +
      + + + + + + + +
        +
      • +

        rebatchRequests

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> rebatchRequests(int n)
        +
        Requests n initially from the upstream and then 75% of n subsequently + after 75% of n values have been emitted to the downstream. + +

        This operator allows preventing the downstream to trigger unbounded mode via request(Long.MAX_VALUE) + or compensate for the per-item overhead of small and frequent requests. + +

        +
        Backpressure:
        +
        The operator expects backpressure from upstream and honors backpressure from downstream.
        +
        Scheduler:
        +
        rebatchRequests does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        n - the initial request amount, further request will happen after 75% of this value
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if n is non-positive
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        reduce

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final @NonNull Maybe<T> reduce(@NonNull BiFunction<T,T,T> reducer)
        +
        Returns a Maybe that applies a specified accumulator function to the first item emitted by the current + Flowable, then feeds the result of that function along with the second item emitted by the current + Flowable into the same function, and so on until all items have been emitted by the current and finite Flowable, + and emits the final result from the final call to your function as its sole item. +

        + +

        + This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," + "compress," or "inject" in other programming contexts. Groovy, for instance, has an inject method + that does a similar operation on lists. +

        + Note that this operator requires the upstream to signal onComplete for the accumulator object to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure of its downstream consumer and consumes the + upstream source in unbounded mode.
        +
        Scheduler:
        +
        reduce does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        reducer - an accumulator function to be invoked on each item emitted by the current Flowable, whose + result will be used in the next accumulator call
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if reducer is null
        +
        See Also:
        +
        ReactiveX operators documentation: Reduce, +Wikipedia: Fold (higher-order function)
        +
        +
        • +
      + + + + + +
        +
      • +

        reduce

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Single<R> reduce(R seed,
+        @NonNull BiFunction<R,? super T,R> reducer)
        +
        Returns a Single that applies a specified accumulator function to the first item emitted by the current + Flowable and a specified seed value, then feeds the result of that function along with the second item + emitted by the current Flowable into the same function, and so on until all items have been emitted by the + current and finite Flowable, emitting the final result from the final call to your function as its sole item. +

        + +

        + This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," + "compress," or "inject" in other programming contexts. Groovy, for instance, has an inject method + that does a similar operation on lists. +

        + Note that the seed is shared among all subscribers to the resulting Flowable + and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer + the application of this operator via defer(Supplier): + 

        
+ Flowable<T> source = ...
+ Single.defer(() -> source.reduce(new ArrayList<>(), (list, item) -> list.add(item)));
+
+ // alternatively, by using compose to stay fluent
+
+ source.compose(o ->
+     Flowable.defer(() -> o.reduce(new ArrayList<>(), (list, item) -> list.add(item)).toFlowable())
+ ).firstOrError();
+
+ // or, by using reduceWith instead of reduce
+
+ source.reduceWith(() -> new ArrayList<>(), (list, item) -> list.add(item)));
+
        +

        + Note that this operator requires the upstream to signal onComplete for the accumulator object to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure of its downstream consumer and consumes the + upstream source in unbounded mode.
        +
        Scheduler:
        +
        reduce does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the accumulator and output value type
        +
        Parameters:
        +
        seed - the initial (seed) accumulator value
        +
        reducer - an accumulator function to be invoked on each item emitted by the current Flowable, the + result of which will be used in the next accumulator call
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if seed or reducer is null
        +
        See Also:
        +
        ReactiveX operators documentation: Reduce, +Wikipedia: Fold (higher-order function), +reduceWith(Supplier, BiFunction)
        +
        +
        • +
      + + + +
        +
      • +

        reduceWith

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Single<R> reduceWith(@NonNull Supplier<R> seedSupplier,
+        @NonNull BiFunction<R,? super T,R> reducer)
        +
        Returns a Single that applies a specified accumulator function to the first item emitted by the current + Flowable and a seed value derived from calling a specified seedSupplier, then feeds the result + of that function along with the second item emitted by the current Flowable into the same function, and so on until + all items have been emitted by the current and finite Flowable, emitting the final result from the final call to your + function as its sole item. +

        + +

        + This technique, which is called "reduce" here, is sometimes called "aggregate", "fold", "accumulate", + "compress", or "inject" in other programming contexts. Groovy, for instance, has an inject method + that does a similar operation on lists. +

        + Note that this operator requires the upstream to signal onComplete for the accumulator object to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure of its downstream consumer and consumes the + upstream source in unbounded mode.
        +
        Scheduler:
        +
        reduceWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the accumulator and output value type
        +
        Parameters:
        +
        seedSupplier - the Supplier that provides the initial (seed) accumulator value for each individual Subscriber
        +
        reducer - an accumulator function to be invoked on each item emitted by the current Flowable, the + result of which will be used in the next accumulator call
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if seedSupplier or reducer is null
        +
        See Also:
        +
        ReactiveX operators documentation: Reduce, +Wikipedia: Fold (higher-order function)
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        repeatWhen

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> repeatWhen(@NonNull Function<? super Flowable<Object>,? extends Publisher<?>> handler)
        +
        Returns a Flowable that emits the same values as the current Flowable with the exception of an + onComplete. An onComplete notification from the source will result in the emission of + a void item to the Flowable provided as an argument to the notificationHandler + function. If that Publisher calls onComplete or onError then repeatWhen will + call onComplete or onError on the child subscription. Otherwise, this Publisher will + resubscribe to the current Flowable. +

        + +

        +
        Backpressure:
        +
        The operator honors downstream backpressure and expects the current Flowable to honor backpressure as well. + If this expectation is violated, the operator may throw an IllegalStateException.
        +
        Scheduler:
        +
        repeatWhen does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        handler - receives a Publisher of notifications with which a user can complete or error, aborting the repeat.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if handler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Repeat
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull ConnectableFlowable<T> replay()
        +
        Returns a ConnectableFlowable that shares a single subscription to the underlying Publisher + that will replay all of its items and notifications to any future Subscriber. A connectable + Flowable resembles an ordinary Flowable, except that it does not begin emitting items when it is + subscribed to, but only when its connect method is called. +

        + +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        This version of replay does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new ConnectableFlowable instance
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector)
        +
        Returns a Flowable that emits items that are the results of invoking a specified selector on the items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable. +

        + +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        This version of replay does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Flowable
        +
        Parameters:
        +
        selector - the selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if selector is null
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector,
+        int bufferSize)
        +
        Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying bufferSize notifications. +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. +

        + +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        This version of replay does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Flowable
        +
        Parameters:
        +
        selector - the selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Flowable
        +
        bufferSize - the buffer size that limits the number of items the operator can replay
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if selector is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay, +replay(Function, int, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector,
+        int bufferSize,
+        boolean eagerTruncate)
        +
        Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying bufferSize notifications. +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. +

        + +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        This version of replay does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Flowable
        +
        Parameters:
        +
        selector - the selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Flowable
        +
        bufferSize - the buffer size that limits the number of items the operator can replay
        +
        eagerTruncate - if true, whenever the internal buffer is truncated to the given bufferSize, the + oldest item will be guaranteed dereferenced, thus avoiding unexpected retention
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if selector is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final <R> @NonNull Flowable<R> replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector,
+        int bufferSize,
+        long time,
+        @NonNull TimeUnit unit)
        +
        Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying no more than bufferSize items that were emitted within a specified time window. +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. +

        + +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        This version of replay operates by default on the computation Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Flowable
        +
        Parameters:
        +
        selector - a selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Flowable
        +
        bufferSize - the buffer size that limits the number of items the operator can replay
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if selector or unit is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+public final <R> @NonNull Flowable<R> replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector,
+        int bufferSize,
+        long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying no more than bufferSize items that were emitted within a specified time window. +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. +

        + +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Flowable
        +
        Parameters:
        +
        selector - a selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Flowable
        +
        bufferSize - the buffer size that limits the number of items the operator can replay
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that is the time source for the window
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if selector, unit or scheduler is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay, +replay(Function, int, long, TimeUnit, Scheduler, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+public final <R> @NonNull Flowable<R> replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector,
+        int bufferSize,
+        long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean eagerTruncate)
        +
        Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying no more than bufferSize items that were emitted within a specified time window. +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. +

        + +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Flowable
        +
        Parameters:
        +
        selector - a selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Flowable
        +
        bufferSize - the buffer size that limits the number of items the operator can replay
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that is the time source for the window
        +
        eagerTruncate - if true, whenever the internal buffer is truncated to the given bufferSize/age, the + oldest item will be guaranteed dereferenced, thus avoiding unexpected retention
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if selector, unit or scheduler is null
        +
        IllegalArgumentException - if bufferSize is less than zero
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final <R> @NonNull Flowable<R> replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector,
+        long time,
+        @NonNull TimeUnit unit)
        +
        Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying all items that were emitted within a specified time window. +

        + +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        This version of replay operates by default on the computation Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Flowable
        +
        Parameters:
        +
        selector - a selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Flowable
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if selector or unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+public final <R> @NonNull Flowable<R> replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector,
+        long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying all items that were emitted within a specified time window. +

        + +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Flowable
        +
        Parameters:
        +
        selector - a selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Flowable
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        scheduler - the scheduler that is the time source for the window
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if selector, unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Replay, +replay(Function, long, TimeUnit, Scheduler, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+public final <R> @NonNull Flowable<R> replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector,
+        long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean eagerTruncate)
        +
        Returns a Flowable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, + replaying all items that were emitted within a specified time window. +

        + +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Flowable
        +
        Parameters:
        +
        selector - a selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Flowable
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        scheduler - the scheduler that is the time source for the window
        +
        eagerTruncate - if true, whenever the internal buffer is truncated to the given age, the + oldest item will be guaranteed dereferenced, thus avoiding unexpected retention
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if selector, unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull ConnectableFlowable<T> replay(int bufferSize)
        +
        Returns a ConnectableFlowable that shares a single subscription to the current Flowable and + replays at most bufferSize items to late Subscribers. A Connectable Flowable resembles + an ordinary Flowable, except that it does not begin emitting items when it is subscribed to, but only + when its connect method is called. +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. + To ensure no beyond-bufferSize items are referenced, + use the replay(int, boolean) overload with eagerTruncate = true. +

        + +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        This version of replay does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        bufferSize - the buffer size that limits the number of items that can be replayed
        +
        Returns:
        +
        the new ConnectableFlowable instance
        +
        Throws:
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay, +replay(int, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull ConnectableFlowable<T> replay(int bufferSize,
+        boolean eagerTruncate)
        +
        Returns a ConnectableFlowable that shares a single subscription to the current Flowable and + replays at most bufferSize items to late Subscribers. A connectable Flowable resembles + an ordinary Flowable, except that it does not begin emitting items when it is subscribed to, but only + when its connect method is called. +

        + +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. + To ensure no beyond-bufferSize items are referenced, set eagerTruncate = true. +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        This version of replay does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        bufferSize - the buffer size that limits the number of items that can be replayed
        +
        eagerTruncate - if true, whenever the internal buffer is truncated to the given bufferSize, the + oldest item will be guaranteed dereferenced, thus avoiding unexpected retention
        +
        Returns:
        +
        the new ConnectableFlowable instance
        +
        Throws:
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull ConnectableFlowable<T> replay(int bufferSize,
+        long time,
+        @NonNull TimeUnit unit)
        +
        Returns a ConnectableFlowable that shares a single subscription to the current Flowable and + replays at most bufferSize items that were emitted during a specified time window. A connectable + Flowable resembles an ordinary Flowable, except that it does not begin emitting items when it is + subscribed to, but only when its connect method is called. +

        + +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. + To ensure no out-of-date or beyond-bufferSize items are referenced, + use the replay(int, long, TimeUnit, Scheduler, boolean) overload with eagerTruncate = true. +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        This version of replay operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        bufferSize - the buffer size that limits the number of items that can be replayed
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        Returns:
        +
        the new ConnectableFlowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay, +replay(int, long, TimeUnit, Scheduler, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull ConnectableFlowable<T> replay(int bufferSize,
+        long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns a ConnectableFlowable that shares a single subscription to the current Flowable and + replays a maximum of bufferSize items that are emitted within a specified time window to late Subscribers. A + connectable Flowable resembles an ordinary Flowable, except that it does not begin emitting items + when it is subscribed to, but only when its connect method is called. +

        + +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. + To ensure no out-of-date or beyond-bufferSize items are referenced, + use the replay(int, long, TimeUnit, Scheduler, boolean) overload with eagerTruncate = true. +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        bufferSize - the buffer size that limits the number of items that can be replayed
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        scheduler - the scheduler that is used as a time source for the window
        +
        Returns:
        +
        the new ConnectableFlowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay, +replay(int, long, TimeUnit, Scheduler, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull ConnectableFlowable<T> replay(int bufferSize,
+        long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean eagerTruncate)
        +
        Returns a ConnectableFlowable that shares a single subscription to the current Flowable and + replays a maximum of bufferSize items that are emitted within a specified time window to late Subscribers. A + connectable Flowable resembles an ordinary Flowable, except that it does not begin emitting items + when it is subscribed to, but only when its connect method is called. +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. To ensure no out-of-date or beyond-bufferSize items + are referenced, set eagerTruncate = true. +

        + +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        bufferSize - the buffer size that limits the number of items that can be replayed
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        scheduler - the scheduler that is used as a time source for the window
        +
        eagerTruncate - if true, whenever the internal buffer is truncated to the given bufferSize/age, the + oldest item will be guaranteed dereferenced, thus avoiding unexpected retention
        +
        Returns:
        +
        the new ConnectableFlowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull ConnectableFlowable<T> replay(long time,
+        @NonNull TimeUnit unit)
        +
        Returns a ConnectableFlowable that shares a single subscription to the current Flowable and + replays all items emitted by it within a specified time window to late Subscribers. A connectable Flowable + resembles an ordinary Flowable, except that it does not begin emitting items when it is subscribed to, + but only when its connect method is called. +

        + +

        + Note that the internal buffer may retain strong references to the oldest item. To ensure no out-of-date items + are referenced, use the replay(long, TimeUnit, Scheduler, boolean) overload with eagerTruncate = true. +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        This version of replay operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        Returns:
        +
        the new ConnectableFlowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + + + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull ConnectableFlowable<T> replay(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean eagerTruncate)
        +
        Returns a ConnectableFlowable that shares a single subscription to the current Flowable and + replays all items emitted by it within a specified time window to late Subscribers. A connectable Flowable + resembles an ordinary Flowable, except that it does not begin emitting items when it is subscribed to, + but only when its connect method is called. +

        + +

        + Note that the internal buffer may retain strong references to the oldest item. To ensure no out-of-date items + are referenced, set eagerTruncate = true. +

        +
        Backpressure:
        +
        This operator supports backpressure. Note that the upstream requests are determined by the child + Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will + request 100 elements from the current Flowable sequence.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that is the time source for the window
        +
        eagerTruncate - if true, whenever the internal buffer is truncated to the given bufferSize/age, the + oldest item will be guaranteed dereferenced, thus avoiding unexpected retention
        +
        Returns:
        +
        the new ConnectableFlowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        retry

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> retry()
        +
        Returns a Flowable that mirrors the current Flowable, resubscribing to it if it calls onError + (infinite retry count). +

        + +

        + If the current Flowable calls Subscriber.onError(java.lang.Throwable), this method will resubscribe to the current + Flowable rather than propagating the onError call. +

        + Any and all items emitted by the current Flowable will be emitted by the resulting Flowable, even + those emitted during failed subscriptions. For example, if the current Flowable fails at first but emits + [1, 2] then succeeds the second time and emits [1, 2, 3, 4, 5] then the complete sequence + of emissions and notifications would be [1, 2, 1, 2, 3, 4, 5, onComplete]. +

        +
        Backpressure:
        +
        The operator honors downstream backpressure and expects the current Flowable to honor backpressure as well. + If this expectation is violated, the operator may throw an IllegalStateException.
        +
        Scheduler:
        +
        retry does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Flowable instance
        +
        See Also:
        +
        ReactiveX operators documentation: Retry
        +
        +
        • +
      + + + + + + + +
        +
      • +

        retry

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> retry(long times)
        +
        Returns a Flowable that mirrors the current Flowable, resubscribing to it if it calls onError + up to a specified number of retries. +

        + +

        + If the current Flowable calls Subscriber.onError(java.lang.Throwable), this method will resubscribe to the current + Flowable for a maximum of count resubscriptions rather than propagating the + onError call. +

        + Any and all items emitted by the current Flowable will be emitted by the resulting Flowable, even + those emitted during failed subscriptions. For example, if the current Flowable fails at first but emits + [1, 2] then succeeds the second time and emits [1, 2, 3, 4, 5] then the complete sequence + of emissions and notifications would be [1, 2, 1, 2, 3, 4, 5, onComplete]. +

        +
        Backpressure:
        +
        The operator honors downstream backpressure and expects the current Flowable to honor backpressure as well. + If this expectation is violated, the operator may throw an IllegalStateException.
        +
        Scheduler:
        +
        retry does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        times - the number of times to resubscribe if the current Flowable fails
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if times is negative
        +
        See Also:
        +
        ReactiveX operators documentation: Retry
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        retryWhen

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> retryWhen(@NonNull Function<? super Flowable<Throwable>,? extends Publisher<?>> handler)
        +
        Returns a Flowable that emits the same values as the current Flowable with the exception of an + onError. An onError notification from the source will result in the emission of a + Throwable item to the Flowable provided as an argument to the notificationHandler + function. If that Publisher calls onComplete or onError then retry will call + onComplete or onError on the child subscription. Otherwise, this Publisher will + resubscribe to the current Flowable. +

        + +

        + Example: + + This retries 3 times, each time incrementing the number of seconds it waits. + + 

        
+  Flowable.create((FlowableEmitter<? super String> s) -> {
+      System.out.println("subscribing");
+      s.onError(new RuntimeException("always fails"));
+  }, BackpressureStrategy.BUFFER).retryWhen(attempts -> {
+      return attempts.zipWith(Flowable.range(1, 3), (n, i) -> i).flatMap(i -> {
+          System.out.println("delay retry by " + i + " second(s)");
+          return Flowable.timer(i, TimeUnit.SECONDS);
+      });
+  }).blockingForEach(System.out::println);
+
        + + Output is: + + 
         
+ subscribing
+ delay retry by 1 second(s)
+ subscribing
+ delay retry by 2 second(s)
+ subscribing
+ delay retry by 3 second(s)
+ subscribing
+
        +

        + Note that the inner Publisher returned by the handler function should signal + either onNext, onError or onComplete in response to the received + Throwable to indicate the operator should retry or terminate. If the upstream to + the operator is asynchronous, signaling onNext followed by onComplete immediately may + result in the sequence to be completed immediately. Similarly, if this inner + Publisher signals onError or onComplete while the upstream is + active, the sequence is terminated with the same signal immediately. +

        + The following example demonstrates how to retry an asynchronous source with a delay: + 

        
+ Flowable.timer(1, TimeUnit.SECONDS)
+     .doOnSubscribe(s -> System.out.println("subscribing"))
+     .map(v -> { throw new RuntimeException(); })
+     .retryWhen(errors -> {
+         AtomicInteger counter = new AtomicInteger();
+         return errors
+                   .takeWhile(e -> counter.getAndIncrement() != 3)
+                   .flatMap(e -> {
+                       System.out.println("delay retry by " + counter.get() + " second(s)");
+                       return Flowable.timer(counter.get(), TimeUnit.SECONDS);
+                   });
+     })
+     .blockingSubscribe(System.out::println, System.out::println);
+
        +
        +
        Backpressure:
        +
        The operator honors downstream backpressure and expects both the source + and inner Publishers to honor backpressure as well. + If this expectation is violated, the operator may throw an IllegalStateException.
        +
        Scheduler:
        +
        retryWhen does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        handler - receives a Publisher of notifications with which a user can complete or error, aborting the + retry
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if handler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Retry
        +
        +
        • +
      + + + +
        +
      • +

        safeSubscribe

        +
        @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public final void safeSubscribe(@NonNull Subscriber<? super T> subscriber)
        +
        Subscribes to the current Flowable and wraps the given Subscriber into a SafeSubscriber + (if not already a SafeSubscriber) that + deals with exceptions thrown by a misbehaving Subscriber (that doesn't follow the + Reactive Streams specification). +
        +
        Backpressure:
        +
        This operator leaves the reactive world and the backpressure behavior depends on the Subscriber's behavior.
        +
        Scheduler:
        +
        safeSubscribe does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        subscriber - the incoming Subscriber instance
        +
        Throws:
        +
        NullPointerException - if subscriber is null
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        sample

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+public final @NonNull Flowable<T> sample(long period,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean emitLast,
+        @NonNull Consumer<? super T> onDropped)
        +
        Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable + within periodic time intervals, where the intervals are defined on a particular Scheduler + and optionally emit the very last upstream item when the upstream completes. +

        + +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time to control data flow.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        period - the sampling rate
        +
        unit - the TimeUnit in which period is defined
        +
        scheduler - the Scheduler to use when sampling
        +
        emitLast - if true and the upstream completes while there is still an unsampled item available, + that item is emitted to downstream before completion + if false, an unsampled last item is ignored.
        +
        onDropped - called with the current entry when it has been replaced by a new one
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null or onDropped is null
        +
        Since:
        +
        3.1.6 - Experimental
        +
        See Also:
        +
        ReactiveX operators documentation: Sample, +RxJava wiki: Backpressure, +throttleLast(long, TimeUnit, Scheduler)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        sample

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+public final <U> @NonNull Flowable<T> sample(@NonNull Publisher<U> sampler,
+        boolean emitLast)
        +
        Returns a Flowable that, when the specified sampler Publisher emits an item or completes, + emits the most recently emitted item (if any) emitted by the current Flowable since the previous + emission from the sampler Publisher + and optionally emit the very last upstream item when the upstream or other Publisher complete. +

        + +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses the emissions of the sampler + Publisher to control data flow.
        +
        Scheduler:
        +
        This version of sample does not operate by default on a particular Scheduler.
        +
        + +

        History: 2.0.5 - experimental

        +
        +
        Type Parameters:
        +
        U - the element type of the sampler Publisher
        +
        Parameters:
        +
        sampler - the Publisher to use for sampling the current Flowable
        +
        emitLast - if true and the upstream completes while there is still an unsampled item available, + that item is emitted to downstream before completion + if false, an unsampled last item is ignored.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sampler is null
        +
        Since:
        +
        2.1
        +
        See Also:
        +
        ReactiveX operators documentation: Sample, +RxJava wiki: Backpressure
        +
        +
        • +
      + + + +
        +
      • +

        scan

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> scan(@NonNull BiFunction<T,T,T> accumulator)
        +
        Returns a Flowable that emits the first value emitted by the current Flowable, then emits one value + for each subsequent value emitted by the current Flowable. Each emission after the first is the result of + applying the specified accumulator function to the previous emission and the corresponding value from the current Flowable. +

        + +

        + This sort of function is sometimes called an accumulator. +

        +
        Backpressure:
        +
        The operator honors downstream backpressure and expects the current Flowable to honor backpressure as well. + Violating this expectation, a MissingBackpressureException may get signaled somewhere downstream.
        +
        Scheduler:
        +
        scan does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        accumulator - an accumulator function to be invoked on each item emitted by the current Flowable, whose + result will be emitted to Subscribers via onNext and used in the + next accumulator call
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if accumulator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Scan
        +
        +
        • +
      + + + + + +
        +
      • +

        scan

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> scan(R initialValue,
+        @NonNull BiFunction<R,? super T,R> accumulator)
        +
        Returns a Flowable that emits the provided initial (seed) value, then emits one value for each value emitted + by the current Flowable. Each emission after the first is the result of applying the specified accumulator + function to the previous emission and the corresponding value from the current Flowable. +

        + +

        + This sort of function is sometimes called an accumulator. +

        + Note that the Flowable that results from this method will emit initialValue as its first + emitted item. +

        + Note that the initialValue is shared among all subscribers to the resulting Flowable + and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer + the application of this operator via defer(Supplier): + 

        
+ Publisher<T> source = ...
+ Flowable.defer(() -> source.scan(new ArrayList<>(), (list, item) -> list.add(item)));
+
+ // alternatively, by using compose to stay fluent
+
+ source.compose(o ->
+     Flowable.defer(() -> o.scan(new ArrayList<>(), (list, item) -> list.add(item)))
+ );
+
        +
        +
        Backpressure:
        +
        The operator honors downstream backpressure and expects the current Flowable to honor backpressure as well. + Violating this expectation, a MissingBackpressureException may get signaled somewhere downstream. + The downstream request pattern is not preserved across this operator. + The upstream is requested bufferSize() - 1 upfront and 75% of bufferSize() thereafter.
        +
        Scheduler:
        +
        scan does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the initial, accumulator and result type
        +
        Parameters:
        +
        initialValue - the initial (seed) accumulator item
        +
        accumulator - an accumulator function to be invoked on each item emitted by the current Flowable, whose + result will be emitted to Subscribers via onNext and used in the + next accumulator call
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if initialValue or accumulator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Scan
        +
        +
        • +
      + + + +
        +
      • +

        scanWith

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> scanWith(@NonNull Supplier<R> seedSupplier,
+        @NonNull BiFunction<R,? super T,R> accumulator)
        +
        Returns a Flowable that emits the provided initial (seed) value, then emits one value for each value emitted + by the current Flowable. Each emission after the first is the result of applying the specified accumulator + function to the previous emission and the corresponding value from the current Flowable. +

        + +

        + This sort of function is sometimes called an accumulator. +

        + Note that the Flowable that results from this method will emit the value returned by + the seedSupplier as its first item. +

        +
        Backpressure:
        +
        The operator honors downstream backpressure and expects the current Flowable to honor backpressure as well. + Violating this expectation, a MissingBackpressureException may get signaled somewhere downstream. + The downstream request pattern is not preserved across this operator. + The upstream is requested bufferSize() - 1 upfront and 75% of bufferSize() thereafter.
        +
        Scheduler:
        +
        scanWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the initial, accumulator and result type
        +
        Parameters:
        +
        seedSupplier - a Supplier that returns the initial (seed) accumulator item for each individual Subscriber
        +
        accumulator - an accumulator function to be invoked on each item emitted by the current Flowable, whose + result will be emitted to Subscribers via onNext and used in the + next accumulator call
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if seedSupplier or accumulator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Scan
        +
        +
        • +
      + + + +
        +
      • +

        serialize

        +
        @CheckReturnValue
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> serialize()
        +
        Forces the current Flowable's emissions and notifications to be serialized and for it to obey + the Publisher contract in other ways. +

        + It is possible for a Publisher to invoke its Subscribers' methods asynchronously, perhaps from + different threads. This could make such a Publisher poorly-behaved, in that it might try to invoke + onComplete or onError before one of its onNext invocations, or it might call + onNext from two different threads concurrently. You can force such a Publisher to be + well-behaved and sequential by applying the serialize method to it. +

        + +

        +
        Backpressure:
        +
        The operator doesn't interfere with backpressure which is determined by the current Flowable's backpressure + behavior.
        +
        Scheduler:
        +
        serialize does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Flowable instance
        +
        See Also:
        +
        ReactiveX operators documentation: Serialize
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        skip

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> skip(long time,
+        @NonNull TimeUnit unit)
        +
        Returns a Flowable that skips values emitted by the current Flowable before a specified time window + elapses. +

        + +

        +
        Backpressure:
        +
        The operator doesn't support backpressure as it uses time to skip an arbitrary number of elements and + thus has to consume the current Flowable in an unbounded manner (i.e., no backpressure applied to it).
        +
        Scheduler:
        +
        skip does not operate on any particular scheduler but uses the current time + from the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        time - the length of the time window to skip
        +
        unit - the time unit of time
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Skip
        +
        +
        • +
      + + + +
        +
      • +

        skip

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<T> skip(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns a Flowable that skips values emitted by the current Flowable before a specified time window + on a specified Scheduler elapses. +

        + +

        +
        Backpressure:
        +
        The operator doesn't support backpressure as it uses time to skip an arbitrary number of elements and + thus has to consume the current Flowable in an unbounded manner (i.e., no backpressure applied to it).
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use for the timed skipping
        +
        +
        +
        Parameters:
        +
        time - the length of the time window to skip
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler on which the timed wait happens
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Skip
        +
        +
        • +
      + + + +
        +
      • +

        skipLast

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> skipLast(int count)
        +
        Returns a Flowable that drops a specified number of items from the end of the sequence emitted by the + current Flowable. +

        + +

        + This Subscriber accumulates a queue long enough to store the first count items. As more items are + received, items are taken from the front of the queue and emitted by the resulting Flowable. This causes + such items to be delayed. +

        +
        Backpressure:
        +
        The operator doesn't interfere with backpressure which is determined by the current Flowable's backpressure + behavior.
        +
        Scheduler:
        +
        This version of skipLast does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - number of items to drop from the end of the source sequence
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if count is less than zero
        +
        See Also:
        +
        ReactiveX operators documentation: SkipLast
        +
        +
        • +
      + + + +
        +
      • +

        skipLast

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> skipLast(long time,
+        @NonNull TimeUnit unit)
        +
        Returns a Flowable that drops items emitted by the current Flowable during a specified time window + before the source completes. +

        + +

        + Note: this action will cache the latest items arriving in the specified time window. +

        +
        Backpressure:
        +
        The operator doesn't support backpressure as it uses time to skip an arbitrary number of elements and + thus has to consume the current Flowable in an unbounded manner (i.e., no backpressure applied to it).
        +
        Scheduler:
        +
        skipLast does not operate on any particular scheduler but uses the current time + from the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: SkipLast
        +
        +
        • +
      + + + +
        +
      • +

        skipLast

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> skipLast(long time,
+        @NonNull TimeUnit unit,
+        boolean delayError)
        +
        Returns a Flowable that drops items emitted by the current Flowable during a specified time window + before the source completes. +

        + +

        + Note: this action will cache the latest items arriving in the specified time window. +

        +
        Backpressure:
        +
        The operator doesn't support backpressure as it uses time to skip an arbitrary number of elements and + thus has to consume the current Flowable in an unbounded manner (i.e., no backpressure applied to it).
        +
        Scheduler:
        +
        skipLast does not operate on any particular scheduler but uses the current time + from the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        delayError - if true, an exception signaled by the current Flowable is delayed until the regular elements are consumed + by the downstream; if false, an exception is immediately signaled and all regular elements dropped
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: SkipLast
        +
        +
        • +
      + + + +
        +
      • +

        skipLast

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<T> skipLast(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns a Flowable that drops items emitted by the current Flowable during a specified time window + (defined on a specified scheduler) before the source completes. +

        + +

        + Note: this action will cache the latest items arriving in the specified time window. +

        +
        Backpressure:
        +
        The operator doesn't support backpressure as it uses time to skip an arbitrary number of elements and + thus has to consume the current Flowable in an unbounded manner (i.e., no backpressure applied to it).
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use for tracking the current time
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        scheduler - the scheduler used as the time source
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: SkipLast
        +
        +
        • +
      + + + +
        +
      • +

        skipLast

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<T> skipLast(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean delayError)
        +
        Returns a Flowable that drops items emitted by the current Flowable during a specified time window + (defined on a specified scheduler) before the source completes. +

        + +

        + Note: this action will cache the latest items arriving in the specified time window. +

        +
        Backpressure:
        +
        The operator doesn't support backpressure as it uses time to skip an arbitrary number of elements and + thus has to consume the current Flowable in an unbounded manner (i.e., no backpressure applied to it).
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use to track the current time
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        scheduler - the scheduler used as the time source
        +
        delayError - if true, an exception signaled by the current Flowable is delayed until the regular elements are consumed + by the downstream; if false, an exception is immediately signaled and all regular elements dropped
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: SkipLast
        +
        +
        • +
      + + + +
        +
      • +

        skipLast

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="custom")
+public final @NonNull Flowable<T> skipLast(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean delayError,
+        int bufferSize)
        +
        Returns a Flowable that drops items emitted by the current Flowable during a specified time window + (defined on a specified scheduler) before the source completes. +

        + +

        + Note: this action will cache the latest items arriving in the specified time window. +

        +
        Backpressure:
        +
        The operator doesn't support backpressure as it uses time to skip an arbitrary number of elements and + thus has to consume the current Flowable in an unbounded manner (i.e., no backpressure applied to it).
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        scheduler - the scheduler used as the time source
        +
        delayError - if true, an exception signaled by the current Flowable is delayed until the regular elements are consumed + by the downstream; if false, an exception is immediately signaled and all regular elements dropped
        +
        bufferSize - the hint about how many elements to expect to be skipped
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: SkipLast
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        sorted

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> sorted()
        +
        Returns a Flowable that emits the events emitted by source Publisher, in a + sorted order. Each item emitted by the Publisher must implement Comparable with respect to all + other items in the sequence. + +

        If any item emitted by this Flowable does not implement Comparable with respect to + all other items emitted by this Flowable, no items will be emitted and the + sequence is terminated with a ClassCastException. +

        Note that calling sorted with long, non-terminating or infinite sources + might cause OutOfMemoryError + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., without applying backpressure to it).
        +
        Scheduler:
        +
        sorted does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Flowable instance
        +
        +
        • +
      + + + +
        +
      • +

        sorted

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> sorted(@NonNull Comparator<? super T> comparator)
        +
        Returns a Flowable that emits the events emitted by source Publisher, in a + sorted order based on a specified comparison function. + +

        Note that calling sorted with long, non-terminating or infinite sources + might cause OutOfMemoryError + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., without applying backpressure to it).
        +
        Scheduler:
        +
        sorted does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        comparator - a function that compares two items emitted by the current Flowable and returns an Integer + that indicates their sort order
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if comparator is null
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        subscribe

        +
        @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Disposable subscribe(@NonNull Consumer<? super T> onNext,
+        @NonNull Consumer<? super Throwable> onError,
+        @NonNull Action onComplete,
+        @NonNull DisposableContainer container)
        +
        Wraps the given onXXX callbacks into a Disposable Subscriber, + adds it to the given DisposableContainer and ensures, that if the upstream + terminates or this particular Disposable is disposed, the Subscriber is removed + from the given container. +

        + The Subscriber will be removed after the callback for the terminal event has been invoked. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner (i.e., no + backpressure is applied to it).
        +
        Scheduler:
        +
        subscribe does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        onNext - the callback for upstream items
        +
        onError - the callback for an upstream error if any
        +
        onComplete - the callback for the upstream completion if any
        +
        container - the DisposableContainer (such as CompositeDisposable) to add and remove the + created Disposable Subscriber
        +
        Returns:
        +
        the Disposable that allows disposing the particular subscription.
        +
        Throws:
        +
        NullPointerException - if onNext, onError, + onComplete or container is null
        +
        Since:
        +
        3.1.0
        +
        +
        • +
      + + + + + + + +
        +
      • +

        subscribe

        +
        @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+public final void subscribe(@NonNull FlowableSubscriber<? super T> subscriber)
        +
        Establish a connection between this Flowable and the given FlowableSubscriber and + start streaming events based on the demand of the FlowableSubscriber. +

        + This is a "factory method" and can be called multiple times, each time starting a new Subscription. +

        + Each Subscription will work for only a single FlowableSubscriber. +

        + If the same FlowableSubscriber instance is subscribed to multiple Flowables and/or the + same Flowable multiple times, it must ensure the serialization over its onXXX + methods manually. +

        + If the Flowable rejects the subscription attempt or otherwise fails it will signal + the error via Subscriber.onError(Throwable). +

        + This subscribe method relaxes the following Reactive Streams rules: +

          +
        • §1.3: onNext should not be called concurrently until onSubscribe returns. + FlowableSubscriber.onSubscribe(Subscription) should make sure a sync or async call triggered by request() is safe.
          • +
        • §2.3: onError or onComplete must not call cancel. + Calling request() or cancel() is NOP at this point.
          • +
        • §2.12: onSubscribe must be called at most once on the same instance. + FlowableSubscriber reuse is not checked and if happens, it is the responsibility of + the FlowableSubscriber to ensure proper serialization of its onXXX methods.
          • +
        • §3.9: negative requests should emit an onError(IllegalArgumentException). + Non-positive requests signal via RxJavaPlugins.onError(Throwable) and the stream is not affected.
          • +
        +
        +
        Backpressure:
        +
        The backpressure behavior/expectation is determined by the supplied FlowableSubscriber.
        +
        Scheduler:
        +
        subscribe does not operate by default on a particular Scheduler.
        +
        +

        History: 2.0.7 - experimental; 2.1 - beta

        +
        +
        Parameters:
        +
        subscriber - the FlowableSubscriber that will consume signals from this Flowable
        +
        Throws:
        +
        NullPointerException - if subscriber is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        subscribeActual

        +
        protected abstract void subscribeActual(@NonNull Subscriber<? super T> subscriber)
        +
        Operator implementations (both source and intermediate) should implement this method that + performs the necessary business logic and handles the incoming Subscribers. +

        There is no need to call any of the plugin hooks on the current Flowable instance or + the Subscriber; all hooks and basic safeguards have been + applied by subscribe(Subscriber) before this method gets called.

        +
        +
        Parameters:
        +
        subscriber - the incoming Subscriber, never null
        +
        +
        • +
      + + + + + +
        +
      • +

        subscribeWith

        +
        @CheckReturnValue
+ @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <E extends Subscriber<? super T>> E subscribeWith(E subscriber)
        +
        Subscribes a given Subscriber (subclass) to this Flowable and returns the given + Subscriber as is. +

        Usage example: + 

        
+ Flowable<Integer> source = Flowable.range(1, 10);
+ CompositeDisposable composite = new CompositeDisposable();
+
+ ResourceSubscriber<Integer> rs = new ResourceSubscriber<>() {
+     // ...
+ };
+
+ composite.add(source.subscribeWith(rs));
+
        + +
        +
        Backpressure:
        +
        The backpressure behavior/expectation is determined by the supplied Subscriber.
        +
        Scheduler:
        +
        subscribeWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        E - the type of the Subscriber to use and return
        +
        Parameters:
        +
        subscriber - the Subscriber (subclass) to use and return, not null
        +
        Returns:
        +
        the input subscriber
        +
        Throws:
        +
        NullPointerException - if subscriber is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        switchIfEmpty

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> switchIfEmpty(@NonNull Publisher<? extends T> other)
        +
        Returns a Flowable that emits the items emitted by the current Flowable or the items of an alternate + Publisher if the current Flowable is empty. +

        + +

        +
        Backpressure:
        +
        If the current Flowable is empty, the alternate Publisher is expected to honor backpressure. + If the current Flowable is non-empty, it is expected to honor backpressure as instead. + In either case, if violated, a MissingBackpressureException may get + signaled somewhere downstream. +
        +
        Scheduler:
        +
        switchIfEmpty does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        other - the alternate Publisher to subscribe to if the source does not emit any items
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if other is null
        +
        Since:
        +
        1.1.0
        +
        +
        • +
      + + + +
        +
      • +

        switchMap

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> switchMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)
        +
        Returns a new Flowable by applying a function that you supply to each item emitted by the current + Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted + of these Publishers. +

        + The resulting Flowable completes if both the current Flowable and the last inner Publisher, if any, complete. + If the current Flowable signals an onError, the inner Publisher is canceled and the error delivered in-sequence. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The outer Publisher is consumed in an + unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor + backpressure but it is not enforced; the operator won't signal a MissingBackpressureException + but the violation may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        switchMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the inner Publishers and the output
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Flowable, returns a + Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap, +switchMapDelayError(Function)
        +
        +
        • +
      + + + +
        +
      • +

        switchMap

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> switchMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        int bufferSize)
        +
        Returns a new Flowable by applying a function that you supply to each item emitted by the current + Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted + of these Publishers. +

        + The resulting Flowable completes if both the current Flowable and the last inner Publisher, if any, complete. + If the current Flowable signals an onError, the inner Publisher is canceled and the error delivered in-sequence. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The outer Publisher is consumed in an + unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor + backpressure but it is not enforced; the operator won't signal a MissingBackpressureException + but the violation may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        switchMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the inner Publishers and the output
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Flowable, returns a + Publisher
        +
        bufferSize - the number of elements to prefetch from the current active inner Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap, +switchMapDelayError(Function, int)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapCompletable

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final @NonNull Completable switchMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper)
        +
        Maps the upstream values into CompletableSources, subscribes to the newer one while + disposing the subscription to the previous CompletableSource, thus keeping at most one + active CompletableSource running. +

        + +

        + Since a CompletableSource doesn't produce any items, the resulting reactive type of + this operator is a Completable that can only indicate successful completion or + a failure in any of the inner CompletableSources or the failure of the current + Flowable. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner and otherwise + does not have backpressure in its return type because no items are ever produced.
        +
        Scheduler:
        +
        switchMapCompletable does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If either this Flowable or the active CompletableSource signals an onError, + the resulting Completable is terminated immediately with that Throwable. + Use the switchMapCompletableDelayError(Function) to delay such inner failures until + every inner CompletableSources and the main Flowable terminates in some fashion. + If they fail concurrently, the operator may combine the Throwables into a + CompositeException + and signal it to the downstream instead. If any inactivated (switched out) CompletableSource + signals an onError late, the Throwables will be signaled to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. +
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Parameters:
        +
        mapper - the function called with each upstream item and should return a + CompletableSource to be subscribed to and awaited for + (non blockingly) for its terminal event
        +
        Returns:
        +
        the new Completable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        switchMapCompletableDelayError(Function)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapCompletableDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final @NonNull Completable switchMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper)
        +
        Maps the upstream values into CompletableSources, subscribes to the newer one while + disposing the subscription to the previous CompletableSource, thus keeping at most one + active CompletableSource running and delaying any main or inner errors until all + of them terminate. +

        + +

        + Since a CompletableSource doesn't produce any items, the resulting reactive type of + this operator is a Completable that can only indicate successful completion or + a failure in any of the inner CompletableSources or the failure of the current + Flowable. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner and otherwise + does not have backpressure in its return type because no items are ever produced.
        +
        Scheduler:
        +
        switchMapCompletableDelayError does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        The errors of this Flowable and all the CompletableSources, who had the chance + to run to their completion, are delayed until + all of them terminate in some fashion. At this point, if there was only one failure, the respective + Throwable is emitted to the downstream. If there was more than one failure, the + operator combines all Throwables into a CompositeException + and signals that to the downstream. + If any inactivated (switched out) CompletableSource + signals an onError late, the Throwables will be signaled to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. +
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Parameters:
        +
        mapper - the function called with each upstream item and should return a + CompletableSource to be subscribed to and awaited for + (non blockingly) for its terminal event
        +
        Returns:
        +
        the new Completable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        switchMapCompletable(Function)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> switchMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)
        +
        Returns a new Flowable by applying a function that you supply to each item emitted by the current + Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted + of these Publishers and delays any error until all Publishers terminate. +

        + The resulting Flowable completes if both the current Flowable and the last inner Publisher, if any, complete. + If the current Flowable signals an onError, the termination of the last inner Publisher will emit that error as is + or wrapped into a CompositeException along with the other possible errors the former inner Publishers signaled. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The outer Publisher is consumed in an + unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor + backpressure but it is not enforced; the operator won't signal a MissingBackpressureException + but the violation may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        switchMapDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the inner Publishers and the output
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Flowable, returns a + Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap, +switchMap(Function)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapDelayError

        +
        @CheckReturnValue
+ @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> switchMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        int bufferSize)
        +
        Returns a new Flowable by applying a function that you supply to each item emitted by the current + Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted + of these Publishers and delays any error until all Publishers terminate. +

        + The resulting Flowable completes if both the current Flowable and the last inner Publisher, if any, complete. + If the current Flowable signals an onError, the termination of the last inner Publisher will emit that error as is + or wrapped into a CompositeException along with the other possible errors the former inner Publishers signaled. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The outer Publisher is consumed in an + unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor + backpressure but it is not enforced; the operator won't signal a MissingBackpressureException + but the violation may lead to OutOfMemoryError due to internal buffer bloat.
        +
        Scheduler:
        +
        switchMapDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the inner Publishers and the output
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Flowable, returns a + Publisher
        +
        bufferSize - the number of elements to prefetch from the current active inner Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap, +switchMap(Function, int)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapMaybe

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> switchMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)
        +
        Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones + while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if + available while failing immediately if this Flowable or any of the + active inner MaybeSources fail. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The main Flowable is consumed in an + unbounded manner (i.e., without backpressure).
        +
        Scheduler:
        +
        switchMapMaybe does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        This operator terminates with an onError if this Flowable or any of + the inner MaybeSources fail while they are active. When this happens concurrently, their + individual Throwable errors may get combined and emitted as a single + CompositeException. Otherwise, a late + (i.e., inactive or switched out) onError from this Flowable or from any of + the inner MaybeSources will be forwarded to the global error handler via + RxJavaPlugins.onError(Throwable) as + UndeliverableException
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        mapper - the function called with the current upstream event and should + return a MaybeSource to replace the current active inner source + and get subscribed to.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        switchMapMaybeDelayError(Function)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapMaybeDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> switchMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)
        +
        Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones + while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if + available, delaying errors from this Flowable or the inner MaybeSources until all terminate. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The main Flowable is consumed in an + unbounded manner (i.e., without backpressure).
        +
        Scheduler:
        +
        switchMapMaybeDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        mapper - the function called with the current upstream event and should + return a MaybeSource to replace the current active inner source + and get subscribed to.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        switchMapMaybe(Function)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapSingle

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> switchMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)
        +
        Maps the upstream items into SingleSources and switches (subscribes) to the newer ones + while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one + while failing immediately if this Flowable or any of the + active inner SingleSources fail. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The main Flowable is consumed in an + unbounded manner (i.e., without backpressure).
        +
        Scheduler:
        +
        switchMapSingle does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        This operator terminates with an onError if this Flowable or any of + the inner SingleSources fail while they are active. When this happens concurrently, their + individual Throwable errors may get combined and emitted as a single + CompositeException. Otherwise, a late + (i.e., inactive or switched out) onError from this Flowable or from any of + the inner SingleSources will be forwarded to the global error handler via + RxJavaPlugins.onError(Throwable) as + UndeliverableException
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        mapper - the function called with the current upstream event and should + return a SingleSource to replace the current active inner source + and get subscribed to.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        switchMapSingleDelayError(Function)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapSingleDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> switchMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)
        +
        Maps the upstream items into SingleSources and switches (subscribes) to the newer ones + while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one, + delaying errors from this Flowable or the inner SingleSources until all terminate. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The main Flowable is consumed in an + unbounded manner (i.e., without backpressure).
        +
        Scheduler:
        +
        switchMapSingleDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        mapper - the function called with the current upstream event and should + return a SingleSource to replace the current active inner source + and get subscribed to.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        switchMapSingle(Function)
        +
        +
        • +
      + + + +
        +
      • +

        take

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> take(long count)
        +
        Returns a Flowable that emits only the first count items emitted by the current Flowable. + If the source emits fewer than count items then all of its items are emitted. +

        + +

        + This method returns a Flowable that will invoke a subscribing Subscriber's + onNext function a maximum of count times before invoking + onComplete. +

        + Limits both the number of upstream items (after which the sequence completes) + and the total downstream request amount requested from the upstream to + possibly prevent the creation of excess items by the upstream. +

        + The operator requests at most the given count of items from upstream even + if the downstream requests more than that. For example, given a take(5), + if the downstream requests 1, a request of 1 is submitted to the upstream + and the operator remembers that only 4 items can be requested now on. A request + of 5 at this point will request 4 from the upstream and any subsequent requests will + be ignored. +

        + Note that requests are negotiated on an operator boundary and take's amount + may not be preserved further upstream. For example, + source.observeOn(Schedulers.computation()).take(5) will still request the + default (128) elements from the given source. +

        +
        Backpressure:
        +
        The current Flowable is consumed in a bounded manner.
        +
        Scheduler:
        +
        This version of take does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - the maximum number of items and the total request amount, non-negative. + Zero will immediately cancel the upstream on subscription and complete + the downstream.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if count is negative
        +
        See Also:
        +
        ReactiveX operators documentation: Take
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        takeLast

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> takeLast(int count)
        +
        Returns a Flowable that emits at most the last count items emitted by the current Flowable. If the source emits fewer than + count items then all of its items are emitted. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream if the count is non-zero; ignores + backpressure if the count is zero as it doesn't signal any values.
        +
        Scheduler:
        +
        This version of takeLast does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - the maximum number of items to emit from the end of the sequence of items emitted by the current + Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if count is negative
        +
        See Also:
        +
        ReactiveX operators documentation: TakeLast
        +
        +
        • +
      + + + + + + + +
        +
      • +

        takeLast

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<T> takeLast(long count,
+        long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns a Flowable that emits at most a specified number of items from the current Flowable that were + emitted in a specified window of time before the current Flowable completed, where the timing information is + provided by a given Scheduler. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., no backpressure is applied to it).
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use for tracking the current time
        +
        +
        +
        Parameters:
        +
        count - the maximum number of items to emit
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that provides the timestamps for the observed items
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if count is less than zero
        +
        See Also:
        +
        ReactiveX operators documentation: TakeLast
        +
        +
        • +
      + + + +
        +
      • +

        takeLast

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+public final @NonNull Flowable<T> takeLast(long count,
+        long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean delayError,
+        int bufferSize)
        +
        Returns a Flowable that emits at most a specified number of items from the current Flowable that were + emitted in a specified window of time before the current Flowable completed, where the timing information is + provided by a given Scheduler. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., no backpressure is applied to it).
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use for tracking the current time
        +
        +
        +
        Parameters:
        +
        count - the maximum number of items to emit
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that provides the timestamps for the observed items
        +
        delayError - if true, an exception signaled by the current Flowable is delayed until the regular elements are consumed + by the downstream; if false, an exception is immediately signaled and all regular elements dropped
        +
        bufferSize - the hint about how many elements to expect to be last
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if count is negative or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: TakeLast
        +
        +
        • +
      + + + + + + + +
        +
      • +

        takeLast

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Flowable<T> takeLast(long time,
+        @NonNull TimeUnit unit,
+        boolean delayError)
        +
        Returns a Flowable that emits the items from the current Flowable that were emitted in a specified + window of time before the current Flowable completed. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., no backpressure is applied to it) but note that this may + lead to OutOfMemoryError due to internal buffer bloat. + Consider using takeLast(long, long, TimeUnit) in this case.
        +
        Scheduler:
        +
        This version of takeLast operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        delayError - if true, an exception signaled by the current Flowable is delayed until the regular elements are consumed + by the downstream; if false, an exception is immediately signaled and all regular elements dropped
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: TakeLast
        +
        +
        • +
      + + + + + + + +
        +
      • +

        takeLast

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<T> takeLast(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean delayError)
        +
        Returns a Flowable that emits the items from the current Flowable that were emitted in a specified + window of time before the current Flowable completed, where the timing information is provided by a specified + Scheduler. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., no backpressure is applied to it) but note that this may + lead to OutOfMemoryError due to internal buffer bloat. + Consider using takeLast(long, long, TimeUnit, Scheduler) in this case.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that provides the timestamps for the observed items
        +
        delayError - if true, an exception signaled by the current Flowable is delayed until the regular elements are consumed + by the downstream; if false, an exception is immediately signaled and all regular elements dropped
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: TakeLast
        +
        +
        • +
      + + + +
        +
      • +

        takeLast

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<T> takeLast(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean delayError,
+        int bufferSize)
        +
        Returns a Flowable that emits the items from the current Flowable that were emitted in a specified + window of time before the current Flowable completed, where the timing information is provided by a specified + Scheduler. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., no backpressure is applied to it) but note that this may + lead to OutOfMemoryError due to internal buffer bloat. + Consider using takeLast(long, long, TimeUnit, Scheduler) in this case.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that provides the timestamps for the observed items
        +
        delayError - if true, an exception signaled by the current Flowable is delayed until the regular elements are consumed + by the downstream; if false, an exception is immediately signaled and all regular elements dropped
        +
        bufferSize - the hint about how many elements to expect to be last
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: TakeLast
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        throttleLatest

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Flowable<T> throttleLatest(long timeout,
+        @NonNull TimeUnit unit)
        +
        Throttles items from the upstream Flowable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them. +

        + +

        + Unlike the option with throttleLatest(long, TimeUnit, boolean), the very last item being held back + (if any) is not emitted when the upstream completes. +

        + If no items were emitted from the upstream during this timeout phase, the next + upstream item is emitted immediately and the timeout window starts from then. +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time to control data flow. + If the downstream is not ready to receive items, a + MissingBackpressureException + will be signaled.
        +
        Scheduler:
        +
        throttleLatest operates by default on the computation Scheduler.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        timeout - the time to wait after an item emission towards the downstream + before trying to emit the latest item from upstream again
        +
        unit - the time unit
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        throttleLatest(long, TimeUnit, boolean), +throttleLatest(long, TimeUnit, Scheduler)
        +
        +
        • +
      + + + +
        +
      • +

        throttleLatest

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Flowable<T> throttleLatest(long timeout,
+        @NonNull TimeUnit unit,
+        boolean emitLast)
        +
        Throttles items from the upstream Flowable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them. +

        + +

        + If no items were emitted from the upstream during this timeout phase, the next + upstream item is emitted immediately and the timeout window starts from then. +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time to control data flow. + If the downstream is not ready to receive items, a + MissingBackpressureException + will be signaled.
        +
        Scheduler:
        +
        throttleLatest operates by default on the computation Scheduler.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        timeout - the time to wait after an item emission towards the downstream + before trying to emit the latest item from upstream again
        +
        unit - the time unit
        +
        emitLast - If true, the very last item from the upstream will be emitted + immediately when the upstream completes, regardless if there is + a timeout window active or not. If false, the very last + upstream item is ignored and the flow terminates.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        throttleLatest(long, TimeUnit, Scheduler, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        throttleLatest

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<T> throttleLatest(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Throttles items from the upstream Flowable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them. +

        + +

        + Unlike the option with throttleLatest(long, TimeUnit, Scheduler, boolean), the very last item being held back + (if any) is not emitted when the upstream completes. +

        + If no items were emitted from the upstream during this timeout phase, the next + upstream item is emitted immediately and the timeout window starts from then. +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time to control data flow. + If the downstream is not ready to receive items, a + MissingBackpressureException + will be signaled.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        timeout - the time to wait after an item emission towards the downstream + before trying to emit the latest item from upstream again
        +
        unit - the time unit
        +
        scheduler - the Scheduler where the timed wait and latest item + emission will be performed
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        throttleLatest(long, TimeUnit, Scheduler, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        throttleLatest

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+public final @NonNull Flowable<T> throttleLatest(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean emitLast)
        +
        Throttles items from the upstream Flowable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them. +

        + +

        + If no items were emitted from the upstream during this timeout phase, the next + upstream item is emitted immediately and the timeout window starts from then. +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time to control data flow. + If the downstream is not ready to receive items, a + MissingBackpressureException + will be signaled.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        timeout - the time to wait after an item emission towards the downstream + before trying to emit the latest item from upstream again
        +
        unit - the time unit
        +
        scheduler - the Scheduler where the timed wait and latest item + emission will be performed
        +
        emitLast - If true, the very last item from the upstream will be emitted + immediately when the upstream completes, regardless if there is + a timeout window active or not. If false, the very last + upstream item is ignored and the flow terminates.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        throttleLatest

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+public final @NonNull Flowable<T> throttleLatest(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean emitLast,
+        @NonNull Consumer<? super T> onDropped)
        +
        Throttles items from the upstream Flowable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them, invoking the consumer for any dropped item. +

        + +

        + If no items were emitted from the upstream during this timeout phase, the next + upstream item is emitted immediately and the timeout window starts from then. +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time to control data flow. + If the downstream is not ready to receive items, a + MissingBackpressureException + will be signaled.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        Error handling:
        +
        + If the upstream signals an onError or onDropped callback crashes, + the error is delivered immediately to the downstream. If both happen, a CompositeException + is created, containing both the upstream and the callback error. + If the onDropped callback crashes during cancellation, the exception is forwarded + to the global error handler via RxJavaPlugins.onError(Throwable). +
        +
        +
        +
        Parameters:
        +
        timeout - the time to wait after an item emission towards the downstream + before trying to emit the latest item from upstream again
        +
        unit - the time unit
        +
        scheduler - the Scheduler where the timed wait and latest item + emission will be performed
        +
        emitLast - If true, the very last item from the upstream will be emitted + immediately when the upstream completes, regardless if there is + a timeout window active or not. If false, the very last + upstream item is ignored and the flow terminates.
        +
        onDropped - called when an item is replaced by a newer item that doesn't get delivered + to the downstream, including the very last item if emitLast is false + and the current undelivered item when the sequence gets canceled.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit, scheduler or onDropped is null
        +
        Since:
        +
        3.1.6 - Experimental
        +
        +
        • +
      + + + +
        +
      • +

        throttleWithTimeout

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Flowable<T> throttleWithTimeout(long timeout,
+        @NonNull TimeUnit unit)
        +
        Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the + current Flowable that are followed by newer items before a timeout value expires. The timer resets on + each emission (alias to debounce(long, TimeUnit)). +

        + Note: If items keep being emitted by the current Flowable faster than the timeout then no items + will be emitted by the resulting Flowable. +

        + +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time to control data flow.
        +
        Scheduler:
        +
        throttleWithTimeout operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timeout - the length of the window of time that must pass after the emission of an item from the current + Flowable in which it emits no items in order for the item to be emitted by the + resulting Flowable
        +
        unit - the unit of time for the specified timeout
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Debounce, +RxJava wiki: Backpressure, +debounce(long, TimeUnit)
        +
        +
        • +
      + + + +
        +
      • +

        throttleWithTimeout

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<T> throttleWithTimeout(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the + current Flowable that are followed by newer items before a timeout value expires on a specified + Scheduler. The timer resets on each emission (alias to debounce(long, TimeUnit, Scheduler)). +

        + Note: If items keep being emitted by the current Flowable faster than the timeout then no items + will be emitted by the resulting Flowable. +

        + +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time to control data flow.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timeout - the length of the window of time that must pass after the emission of an item from the current + Flowable in which it emits no items in order for the item to be emitted by the + resulting Flowable
        +
        unit - the unit of time for the specified timeout
        +
        scheduler - the Scheduler to use internally to manage the timers that handle the timeout for each + item
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Debounce, +RxJava wiki: Backpressure, +debounce(long, TimeUnit, Scheduler)
        +
        +
        • +
      + + + +
        +
      • +

        throttleWithTimeout

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<T> throttleWithTimeout(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        @NonNull Consumer<? super T> onDropped)
        +
        Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the + current Flowable that are followed by newer items before a timeout value expires on a specified + Scheduler. The timer resets on each emission (alias to debounce(long, TimeUnit, Scheduler, Consumer)). +

        + Note: If items keep being emitted by the current Flowable faster than the timeout then no items + will be emitted by the resulting Flowable. +

        + +

        +
        Backpressure:
        +
        This operator does not support backpressure as it uses time to control data flow.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timeout - the length of the window of time that must pass after the emission of an item from the current + Flowable in which it emits no items in order for the item to be emitted by the + resulting Flowable
        +
        unit - the unit of time for the specified timeout
        +
        scheduler - the Scheduler to use internally to manage the timers that handle the timeout for each + item
        +
        onDropped - called with the current entry when it has been replaced by a new one
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null or onDropped is null
        +
        Since:
        +
        3.1.6 - Experimental
        +
        See Also:
        +
        ReactiveX operators documentation: Debounce, +RxJava wiki: Backpressure, +debounce(long, TimeUnit, Scheduler, Consumer)
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <V> @NonNull Flowable<T> timeout(@NonNull Function<? super T,? extends Publisher<V>> itemTimeoutIndicator)
        +
        Returns a Flowable that mirrors the current Flowable, but notifies Subscribers of a + TimeoutException if an item emitted by the current Flowable doesn't arrive within a window of + time after the emission of the previous item, where that period of time is measured by a Publisher that + is a function of the previous item. +

        + +

        + Note: The arrival of the first source item is never timed out. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The Publisher + sources are expected to honor backpressure as well. + If any of the current Flowables violate this, it may throw an + IllegalStateException when the current Flowable completes.
        +
        Scheduler:
        +
        This version of timeout operates by default on the immediate Scheduler.
        +
        +
        +
        Type Parameters:
        +
        V - the timeout value type (ignored)
        +
        Parameters:
        +
        itemTimeoutIndicator - a function that returns a Publisher for each item emitted by the current + Flowable and that determines the timeout window for the subsequent item
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if itemTimeoutIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <V> @NonNull Flowable<T> timeout(@NonNull Function<? super T,? extends Publisher<V>> itemTimeoutIndicator,
+        @NonNull Publisher<? extends T> fallback)
        +
        Returns a Flowable that mirrors the current Flowable, but that switches to a fallback Publisher if + an item emitted by the current Flowable doesn't arrive within a window of time after the emission of the + previous item, where that period of time is measured by a Publisher that is a function of the previous + item. +

        + +

        + Note: The arrival of the first source item is never timed out. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The Publisher + sources are expected to honor backpressure as well. + If any of the current Flowables violate this, it may throw an + IllegalStateException when the current Flowable completes.
        +
        Scheduler:
        +
        This version of timeout operates by default on the immediate Scheduler.
        +
        +
        +
        Type Parameters:
        +
        V - the timeout value type (ignored)
        +
        Parameters:
        +
        itemTimeoutIndicator - a function that returns a Publisher, for each item emitted by the current Flowable, that + determines the timeout window for the subsequent item
        +
        fallback - the fallback Publisher to switch to if the current Flowable times out
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if itemTimeoutIndicator or fallback is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + + + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="io.reactivex:computation")
+public final @NonNull Flowable<T> timeout(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Publisher<? extends T> fallback)
        +
        Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted + item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, + the current Flowable is disposed and the resulting Flowable begins instead to mirror a fallback Publisher. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The Publisher + sources are expected to honor backpressure as well. + If any of the current Flowables violate this, it may throw an + IllegalStateException when the current Flowable completes.
        +
        Scheduler:
        +
        This version of timeout operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timeout - maximum duration between items before a timeout occurs
        +
        unit - the unit of time that applies to the timeout argument
        +
        fallback - the fallback Publisher to use in case of a timeout
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or fallback is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+public final @NonNull Flowable<T> timeout(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        @NonNull Publisher<? extends T> fallback)
        +
        Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted + item using a specified Scheduler. If the next item isn't emitted within the specified timeout duration + starting from its predecessor, the current Flowable is disposed and the resulting Flowable begins + instead to mirror a fallback Publisher. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The Publisher + sources are expected to honor backpressure as well. + If any of the current Flowables violate this, it may throw an + IllegalStateException when the current Flowable completes.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timeout - maximum duration between items before a timeout occurs
        +
        unit - the unit of time that applies to the timeout argument
        +
        scheduler - the Scheduler to run the timeout timers on
        +
        fallback - the Publisher to use as the fallback in case of a timeout
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit, scheduler or fallback is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<T> timeout(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted + item, where this policy is governed by a specified Scheduler. If the next item isn't emitted within the + specified timeout duration starting from its predecessor, the resulting Flowable terminates and + notifies Subscribers of a TimeoutException. +

        + +

        +
        Backpressure:
        +
        The operator doesn't interfere with backpressure which is determined by the current Flowable's backpressure + behavior.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timeout - maximum duration between items before a timeout occurs
        +
        unit - the unit of time that applies to the timeout argument
        +
        scheduler - the Scheduler to run the timeout timers on
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public final <U,V> @NonNull Flowable<T> timeout(@NonNull Publisher<U> firstTimeoutIndicator,
+        @NonNull Function<? super T,? extends Publisher<V>> itemTimeoutIndicator)
        +
        Returns a Flowable that mirrors the current Flowable, but notifies Subscribers of a + TimeoutException if either the first item emitted by the current Flowable or any subsequent item + doesn't arrive within time windows defined by other Publishers. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. Both this and the returned Publishers + are expected to honor backpressure as well. If any of then violates this rule, it may throw an + IllegalStateException when the Publisher completes.
        +
        Scheduler:
        +
        timeout does not operate by default on any Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the first timeout value type (ignored)
        +
        V - the subsequent timeout value type (ignored)
        +
        Parameters:
        +
        firstTimeoutIndicator - a function that returns a Publisher that determines the timeout window for the first source + item
        +
        itemTimeoutIndicator - a function that returns a Publisher for each item emitted by the current Flowable and that + determines the timeout window in which the subsequent source item must arrive in order to + continue the sequence
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if firstTimeoutIndicator or itemTimeoutIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <U,V> @NonNull Flowable<T> timeout(@NonNull Publisher<U> firstTimeoutIndicator,
+        @NonNull Function<? super T,? extends Publisher<V>> itemTimeoutIndicator,
+        @NonNull Publisher<? extends T> fallback)
        +
        Returns a Flowable that mirrors the current Flowable, but switches to a fallback Publisher if either + the first item emitted by the current Flowable or any subsequent item doesn't arrive within time windows + defined by other Publishers. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The Publisher + sources are expected to honor backpressure as well. + If any of the current Flowables violate this, it may throw an + IllegalStateException when the current Flowable completes.
        +
        Scheduler:
        +
        timeout does not operate by default on any Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the first timeout value type (ignored)
        +
        V - the subsequent timeout value type (ignored)
        +
        Parameters:
        +
        firstTimeoutIndicator - a function that returns a Publisher which determines the timeout window for the first source + item
        +
        itemTimeoutIndicator - a function that returns a Publisher for each item emitted by the current Flowable and that + determines the timeout window in which the subsequent source item must arrive in order to + continue the sequence
        +
        fallback - the fallback Publisher to switch to if the current Flowable times out
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if firstTimeoutIndicator, itemTimeoutIndicator or fallback is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        to

        +
        @CheckReturnValue
+ @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+public final <R> R to(@NonNull FlowableConverter<T,? extends R> converter)
        +
        Calls the specified converter function during assembly time and returns its resulting value. +

        + This allows fluent conversion to any other type. +

        +
        Backpressure:
        +
        The backpressure behavior depends on what happens in the converter function.
        +
        Scheduler:
        +
        to does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.7 - experimental

        +
        +
        Type Parameters:
        +
        R - the resulting object type
        +
        Parameters:
        +
        converter - the function that receives the current Flowable instance and returns a value
        +
        Returns:
        +
        the converted value
        +
        Throws:
        +
        NullPointerException - if converter is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        toList

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Single<List<T>> toList()
        +
        Returns a Single that emits a single item, a list composed of all the items emitted by the + finite upstream source Publisher. +

        + +

        + Normally, a Publisher that returns multiple items will do so by invoking its Subscriber's + onNext method for each such item. You can change this behavior by having the + operator compose a list of all of these items and then to invoke the SingleObserver's onSuccess + method once, passing it the entire list, by calling the Flowable's toList method prior to + calling its subscribe() method. +

        + Note that this operator requires the upstream to signal onComplete for the accumulated list to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., without applying backpressure to it).
        +
        Scheduler:
        +
        toList does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Single instance
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toList

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Single<List<T>> toList(int capacityHint)
        +
        Returns a Single that emits a single item, a list composed of all the items emitted by the + finite source Publisher. +

        + +

        + Normally, a Publisher that returns multiple items will do so by invoking its Subscriber's + onNext method for each such item. You can change this behavior by having the + operator compose a list of all of these items and then to invoke the SingleObserver's onSuccess + method once, passing it the entire list, by calling the Flowable's toList method prior to + calling its subscribe() method. +

        + Note that this operator requires the upstream to signal onComplete for the accumulated list to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., without applying backpressure to it).
        +
        Scheduler:
        +
        toList does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        capacityHint - the number of elements expected from the current Flowable
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toList

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U extends Collection<? super T>> @NonNull Single<U> toList(@NonNull Supplier<U> collectionSupplier)
        +
        Returns a Single that emits a single item, a list composed of all the items emitted by the + finite source Publisher. +

        + +

        + Normally, a Publisher that returns multiple items will do so by invoking its Subscriber's + onNext method for each such item. You can change this behavior by having the + operator compose a collection of all of these items and then to invoke the SingleObserver's onSuccess + method once, passing it the entire collection, by calling the Flowable's toList method prior to + calling its subscribe() method. +

        + Note that this operator requires the upstream to signal onComplete for the accumulated collection to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., without applying backpressure to it).
        +
        Scheduler:
        +
        toList does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the subclass of a collection of Ts
        +
        Parameters:
        +
        collectionSupplier - the Supplier returning the collection (for each individual Subscriber) to be filled in
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if collectionSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toMap

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <K> @NonNull Single<Map<K,T>> toMap(@NonNull Function<? super T,? extends K> keySelector)
        +
        Returns a Single that emits a single HashMap containing all items emitted by the finite source Publisher, + mapped by the keys returned by a specified keySelector function. +

        + +

        + If more than one source item maps to the same key, the HashMap will contain the latest of those items. +

        + Note that this operator requires the upstream to signal onComplete for the accumulated map to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., without applying backpressure to it).
        +
        Scheduler:
        +
        toMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type of the Map
        +
        Parameters:
        +
        keySelector - the function that extracts the key from a source item to be used in the HashMap
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if keySelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toMap

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <K,V> @NonNull Single<Map<K,V>> toMap(@NonNull Function<? super T,? extends K> keySelector,
+        @NonNull Function<? super T,? extends V> valueSelector)
        +
        Returns a Single that emits a single HashMap containing values corresponding to items emitted by the + finite source Publisher, mapped by the keys returned by a specified keySelector function. +

        + +

        + If more than one source item maps to the same key, the HashMap will contain a single entry that + corresponds to the latest of those items. +

        + Note that this operator requires the upstream to signal onComplete for the accumulated map to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., without applying backpressure to it).
        +
        Scheduler:
        +
        toMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type of the Map
        +
        V - the value type of the Map
        +
        Parameters:
        +
        keySelector - the function that extracts the key from a source item to be used in the HashMap
        +
        valueSelector - the function that extracts the value from a source item to be used in the HashMap
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if keySelector or valueSelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toMap

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <K,V> @NonNull Single<Map<K,V>> toMap(@NonNull Function<? super T,? extends K> keySelector,
+        @NonNull Function<? super T,? extends V> valueSelector,
+        @NonNull Supplier<? extends Map<K,V>> mapSupplier)
        +
        Returns a Single that emits a single Map, returned by a specified mapFactory function, that + contains keys and values extracted from the items emitted by the finite source Publisher. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated map to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., without applying backpressure to it).
        +
        Scheduler:
        +
        toMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type of the Map
        +
        V - the value type of the Map
        +
        Parameters:
        +
        keySelector - the function that extracts the key from a source item to be used in the Map
        +
        valueSelector - the function that extracts the value from the source items to be used as value in the Map
        +
        mapSupplier - the function that returns a Map instance to be used
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if keySelector, valueSelector or mapSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + + + + + +
        +
      • +

        toMultimap

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K,V> @NonNull Single<Map<K,Collection<V>>> toMultimap(@NonNull Function<? super T,? extends K> keySelector,
+        @NonNull Function<? super T,? extends V> valueSelector)
        +
        Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a + specified valueSelector function from items emitted by the finite source Publisher, keyed by a + specified keySelector function. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated map to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., without applying backpressure to it).
        +
        Scheduler:
        +
        toMultimap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type of the Map
        +
        V - the value type of the Map
        +
        Parameters:
        +
        keySelector - the function that extracts a key from the source items to be used as key in the HashMap
        +
        valueSelector - the function that extracts a value from the source items to be used as value in the HashMap
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if keySelector or valueSelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toMultimap

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <K,V> @NonNull Single<Map<K,Collection<V>>> toMultimap(@NonNull Function<? super T,? extends K> keySelector,
+        @NonNull Function<? super T,? extends V> valueSelector,
+        @NonNull Supplier<? extends Map<K,Collection<V>>> mapSupplier,
+        @NonNull Function<? super K,? extends Collection<? super V>> collectionFactory)
        +
        Returns a Single that emits a single Map, returned by a specified mapFactory function, that + contains a custom collection of values, extracted by a specified valueSelector function from + items emitted by the finite source Publisher, and keyed by the keySelector function. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated map to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., without applying backpressure to it).
        +
        Scheduler:
        +
        toMultimap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type of the Map
        +
        V - the value type of the Map
        +
        Parameters:
        +
        keySelector - the function that extracts a key from the source items to be used as the key in the Map
        +
        valueSelector - the function that extracts a value from the source items to be used as the value in the Map
        +
        mapSupplier - the function that returns a Map instance to be used
        +
        collectionFactory - the function that returns a Collection instance for a particular key to be used in the Map
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if keySelector, valueSelector, mapSupplier or collectionFactory is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toMultimap

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K,V> @NonNull Single<Map<K,Collection<V>>> toMultimap(@NonNull Function<? super T,? extends K> keySelector,
+        @NonNull Function<? super T,? extends V> valueSelector,
+        @NonNull Supplier<Map<K,Collection<V>>> mapSupplier)
        +
        Returns a Single that emits a single Map, returned by a specified mapFactory function, that + contains an ArrayList of values, extracted by a specified valueSelector function from items + emitted by the finite source Publisher and keyed by the keySelector function. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated map to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., without applying backpressure to it).
        +
        Scheduler:
        +
        toMultimap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type of the Map
        +
        V - the value type of the Map
        +
        Parameters:
        +
        keySelector - the function that extracts a key from the source items to be used as the key in the Map
        +
        valueSelector - the function that extracts a value from the source items to be used as the value in the Map
        +
        mapSupplier - the function that returns a Map instance to be used
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if keySelector, valueSelector or mapSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + + + + + +
        +
      • +

        toSortedList

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Single<List<T>> toSortedList()
        +
        Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a + sorted order. Each item emitted by the Publisher must implement Comparable with respect to all + other items in the sequence. + +

        If any item emitted by this Flowable does not implement Comparable with respect to + all other items emitted by this Flowable, no items will be emitted and the + sequence is terminated with a ClassCastException. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated list to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., without applying backpressure to it).
        +
        Scheduler:
        +
        toSortedList does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Single instance
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toSortedList

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final @NonNull Single<List<T>> toSortedList(@NonNull Comparator<? super T> comparator)
        +
        Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a + sorted order based on a specified comparison function. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated list to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., without applying backpressure to it).
        +
        Scheduler:
        +
        toSortedList does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        comparator - a function that compares two items emitted by the current Flowable and returns an int + that indicates their sort order
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if comparator is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toSortedList

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final @NonNull Single<List<T>> toSortedList(@NonNull Comparator<? super T> comparator,
+        int capacityHint)
        +
        Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a + sorted order based on a specified comparison function. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated list to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., without applying backpressure to it).
        +
        Scheduler:
        +
        toSortedList does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        comparator - a function that compares two items emitted by the current Flowable and returns an int + that indicates their sort order
        +
        capacityHint - the initial capacity of the ArrayList used to accumulate items before sorting
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if comparator is null
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toSortedList

        +
        @CheckReturnValue
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Single<List<T>> toSortedList(int capacityHint)
        +
        Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a + sorted order. Each item emitted by the Publisher must implement Comparable with respect to all + other items in the sequence. + +

        If any item emitted by this Flowable does not implement Comparable with respect to + all other items emitted by this Flowable, no items will be emitted and the + sequence is terminated with a ClassCastException. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated list to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and consumes the current Flowable in an + unbounded manner (i.e., without applying backpressure to it).
        +
        Scheduler:
        +
        toSortedList does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        capacityHint - the initial capacity of the ArrayList used to accumulate items before sorting
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + + + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<Flowable<T>> window(long count)
        +
        Returns a Flowable that emits windows of items it collects from the current Flowable. The resulting + Flowable emits connected, non-overlapping windows, each containing count items. When the current + Flowable completes or encounters an error, the resulting Flowable emits the current window and + propagates the notification from the current Flowable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window will only contain one element. The behavior is + a trade-off between no-dataloss and ensuring upstream cancellation can happen. +

        +
        Backpressure:
        +
        The operator honors backpressure of its inner and outer subscribers, however, the inner Flowable uses an + unbounded buffer that may hold at most count elements.
        +
        Scheduler:
        +
        This version of window does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - the maximum size of each window before it should be emitted
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<Flowable<T>> window(long count,
+        long skip)
        +
        Returns a Flowable that emits windows of items it collects from the current Flowable. The resulting + Flowable emits windows every skip items, each containing no more than count items. When + the current Flowable completes or encounters an error, the resulting Flowable emits the current window + and propagates the notification from the current Flowable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off between no-dataloss and ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The operator honors backpressure of its inner and outer subscribers, however, the inner Flowable uses an + unbounded buffer that may hold at most count elements.
        +
        Scheduler:
        +
        This version of window does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - the maximum size of each window before it should be emitted
        +
        skip - how many items need to be skipped before starting a new window. Note that if skip and + count are equal this is the same operation as window(long).
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if count or skip is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<Flowable<T>> window(long count,
+        long skip,
+        int bufferSize)
        +
        Returns a Flowable that emits windows of items it collects from the current Flowable. The resulting + Flowable emits windows every skip items, each containing no more than count items. When + the current Flowable completes or encounters an error, the resulting Flowable emits the current window + and propagates the notification from the current Flowable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off between no-dataloss and ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The operator honors backpressure of its inner and outer subscribers, however, the inner Flowable uses an + unbounded buffer that may hold at most count elements.
        +
        Scheduler:
        +
        This version of window does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - the maximum size of each window before it should be emitted
        +
        skip - how many items need to be skipped before starting a new window. Note that if skip and + count are equal this is the same operation as window(long).
        +
        bufferSize - the capacity hint for the buffer in the inner windows
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if count, skip or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Flowable<Flowable<T>> window(long timespan,
+        long timeskip,
+        @NonNull TimeUnit unit)
        +
        Returns a Flowable that emits windows of items it collects from the current Flowable. The resulting + Flowable starts a new window periodically, as determined by the timeskip argument. It emits + each window after a fixed timespan, specified by the timespan argument. When the current + Flowable completes or encounters an error, the resulting Flowable emits the + current window and propagates the notification from the current Flowable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner. + The resulting Flowable doesn't support backpressure as it uses + time to control the creation of windows. The emitted inner Flowables honor + backpressure but have an unbounded inner buffer that may lead to OutOfMemoryError + if left unconsumed.
        +
        Scheduler:
        +
        This version of window operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted
        +
        timeskip - the period of time after which a new window will be created
        +
        unit - the unit of time that applies to the timespan and timeskip arguments
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<Flowable<T>> window(long timespan,
+        long timeskip,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns a Flowable that emits windows of items it collects from the current Flowable. The resulting + Flowable starts a new window periodically, as determined by the timeskip argument. It emits + each window after a fixed timespan, specified by the timespan argument. When the current + Flowable completes or encounters an error, the resulting Flowable emits the + current window and propagates the notification from the current Flowable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner. + The resulting Flowable doesn't support backpressure as it uses + time to control the creation of windows. The returned inner Flowables honor + backpressure but have an unbounded inner buffer that may lead to OutOfMemoryError + if left unconsumed.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted
        +
        timeskip - the period of time after which a new window will be created
        +
        unit - the unit of time that applies to the timespan and timeskip arguments
        +
        scheduler - the Scheduler to use when determining the end and start of a window
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+public final @NonNull Flowable<Flowable<T>> window(long timespan,
+        long timeskip,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        int bufferSize)
        +
        Returns a Flowable that emits windows of items it collects from the current Flowable. The resulting + Flowable starts a new window periodically, as determined by the timeskip argument. It emits + each window after a fixed timespan, specified by the timespan argument. When the current + Flowable completes or encounters an error, the resulting Flowable emits the + current window and propagates the notification from the current Flowable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner. + The resulting Flowable doesn't support backpressure as it uses + time to control the creation of windows. The returned inner Flowables honor + backpressure but have an unbounded inner buffer that may lead to OutOfMemoryError + if left unconsumed.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted
        +
        timeskip - the period of time after which a new window will be created
        +
        unit - the unit of time that applies to the timespan and timeskip arguments
        +
        scheduler - the Scheduler to use when determining the end and start of a window
        +
        bufferSize - the capacity hint for the buffer in the inner windows
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if timespan, timeskip or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Flowable<Flowable<T>> window(long timespan,
+        @NonNull TimeUnit unit)
        +
        Returns a Flowable that emits windows of items it collects from the current Flowable. The resulting + Flowable emits connected, non-overlapping windows, each of a fixed duration specified by the + timespan argument. When the current Flowable completes or encounters an error, the resulting + Flowable emits the current window and propagates the notification from the current Flowable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner. + The resulting Flowable doesn't support backpressure as it uses + time to control the creation of windows. The emitted inner Flowables honor + backpressure and may hold up to count elements at most.
        +
        Scheduler:
        +
        This version of window operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted and replaced with a + new window
        +
        unit - the unit of time that applies to the timespan argument
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Flowable<Flowable<T>> window(long timespan,
+        @NonNull TimeUnit unit,
+        long count)
        +
        Returns a Flowable that emits windows of items it collects from the current Flowable. The resulting + Flowable emits connected, non-overlapping windows, each of a fixed duration as specified by the + timespan argument or a maximum size as specified by the count argument (whichever is + reached first). When the current Flowable completes or encounters an error, the resulting Flowable + emits the current window and propagates the notification from the current Flowable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner. + The resulting Flowable doesn't support backpressure as it uses + time to control the creation of windows. The emitted inner Flowables honor + backpressure and may hold up to count elements at most.
        +
        Scheduler:
        +
        This version of window operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted and replaced with a + new window
        +
        unit - the unit of time that applies to the timespan argument
        +
        count - the maximum size of each window before it should be emitted
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Flowable<Flowable<T>> window(long timespan,
+        @NonNull TimeUnit unit,
+        long count,
+        boolean restart)
        +
        Returns a Flowable that emits windows of items it collects from the current Flowable. The resulting + Flowable emits connected, non-overlapping windows, each of a fixed duration as specified by the + timespan argument or a maximum size as specified by the count argument (whichever is + reached first). When the current Flowable completes or encounters an error, the resulting Flowable + emits the current window and propagates the notification from the current Flowable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner. + The resulting Flowable doesn't support backpressure as it uses + time to control the creation of windows. The emitted inner Flowables honor + backpressure and may hold up to count elements at most.
        +
        Scheduler:
        +
        This version of window operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted and replaced with a + new window
        +
        unit - the unit of time that applies to the timespan argument
        +
        count - the maximum size of each window before it should be emitted
        +
        restart - if true, when a window reaches the capacity limit, the timer is restarted as well
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<Flowable<T>> window(long timespan,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns a Flowable that emits windows of items it collects from the current Flowable. The resulting + Flowable emits connected, non-overlapping windows, each of a fixed duration as specified by the + timespan argument. When the current Flowable completes or encounters an error, the resulting + Flowable emits the current window and propagates the notification from the current Flowable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner. + The resulting Flowable doesn't support backpressure as it uses + time to control the creation of windows. The emitted inner Flowables honor + backpressure but have an unbounded inner buffer that may lead to OutOfMemoryError + if left unconsumed.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted and replaced with a + new window
        +
        unit - the unit of time which applies to the timespan argument
        +
        scheduler - the Scheduler to use when determining the end and start of a window
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<Flowable<T>> window(long timespan,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        long count)
        +
        Returns a Flowable that emits windows of items it collects from the current Flowable. The resulting + Flowable emits connected, non-overlapping windows, each of a fixed duration specified by the + timespan argument or a maximum size specified by the count argument (whichever is reached + first). When the current Flowable completes or encounters an error, the resulting Flowable emits the + current window and propagates the notification from the current Flowable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner. + The resulting Flowable doesn't support backpressure as it uses + time to control the creation of windows. The emitted inner Flowables honor + backpressure and may hold up to count elements at most.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted and replaced with a + new window
        +
        unit - the unit of time which applies to the timespan argument
        +
        count - the maximum size of each window before it should be emitted
        +
        scheduler - the Scheduler to use when determining the end and start of a window
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Flowable<Flowable<T>> window(long timespan,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        long count,
+        boolean restart)
        +
        Returns a Flowable that emits windows of items it collects from the current Flowable. The resulting + Flowable emits connected, non-overlapping windows, each of a fixed duration specified by the + timespan argument or a maximum size specified by the count argument (whichever is reached + first). When the current Flowable completes or encounters an error, the resulting Flowable emits the + current window and propagates the notification from the current Flowable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner. + The resulting Flowable doesn't support backpressure as it uses + time to control the creation of windows. The emitted inner Flowables honor + backpressure and may hold up to count elements at most.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted and replaced with a + new window
        +
        unit - the unit of time which applies to the timespan argument
        +
        count - the maximum size of each window before it should be emitted
        +
        scheduler - the Scheduler to use when determining the end and start of a window
        +
        restart - if true, when a window reaches the capacity limit, the timer is restarted as well
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="custom")
+public final @NonNull Flowable<Flowable<T>> window(long timespan,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        long count,
+        boolean restart,
+        int bufferSize)
        +
        Returns a Flowable that emits windows of items it collects from the current Flowable. The resulting + Flowable emits connected, non-overlapping windows, each of a fixed duration specified by the + timespan argument or a maximum size specified by the count argument (whichever is reached + first). When the current Flowable completes or encounters an error, the resulting Flowable emits the + current window and propagates the notification from the current Flowable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The operator consumes the current Flowable in an unbounded manner. + The resulting Flowable doesn't support backpressure as it uses + time to control the creation of windows. The emitted inner Flowables honor + backpressure and may hold up to count elements at most.
        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted and replaced with a + new window
        +
        unit - the unit of time which applies to the timespan argument
        +
        count - the maximum size of each window before it should be emitted
        +
        scheduler - the Scheduler to use when determining the end and start of a window
        +
        restart - if true, when a window reaches the capacity limit, the timer is restarted as well
        +
        bufferSize - the capacity hint for the buffer in the inner windows
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if count, timespan or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <B> @NonNull Flowable<Flowable<T>> window(@NonNull Publisher<B> boundaryIndicator)
        +
        Returns a Flowable that emits non-overlapping windows of items it collects from the current Flowable + where the boundary of each window is determined by the items emitted from a specified boundary-governing + Publisher. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The outer Publisher of this operator does not support backpressure as it uses a boundary Publisher to control data + flow. The inner Publishers honor backpressure and buffer everything until the boundary signals the next element.
        +
        Scheduler:
        +
        This version of window does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        B - the window element type (ignored)
        +
        Parameters:
        +
        boundaryIndicator - a Publisher whose emitted items close and open windows
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if boundaryIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+public final <B> @NonNull Flowable<Flowable<T>> window(@NonNull Publisher<B> boundaryIndicator,
+        int bufferSize)
        +
        Returns a Flowable that emits non-overlapping windows of items it collects from the current Flowable + where the boundary of each window is determined by the items emitted from a specified boundary-governing + Publisher. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The outer Publisher of this operator does not support backpressure as it uses a boundary Publisher to control data + flow. The inner Publishers honor backpressure and buffer everything until the boundary signals the next element.
        +
        Scheduler:
        +
        This version of window does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        B - the window element type (ignored)
        +
        Parameters:
        +
        boundaryIndicator - a Publisher whose emitted items close and open windows
        +
        bufferSize - the capacity hint for the buffer in the inner windows
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if boundaryIndicator is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,V> @NonNull Flowable<Flowable<T>> window(@NonNull Publisher<U> openingIndicator,
+        @NonNull Function<? super U,? extends Publisher<V>> closingIndicator)
        +
        Returns a Flowable that emits windows of items it collects from the current Flowable. The resulting + Flowable emits windows that contain those items emitted by the current Flowable between the time when + the windowOpenings Publisher emits an item and when the Publisher returned by + closingSelector emits an item. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The outer Publisher of this operator doesn't support backpressure because the emission of new + inner Publishers are controlled by the windowOpenings Publisher. + The inner Publishers honor backpressure and buffer everything until the associated closing + Publisher signals or completes.
        +
        Scheduler:
        +
        This version of window does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the element type of the window-opening Publisher
        +
        V - the element type of the window-closing Publishers
        +
        Parameters:
        +
        openingIndicator - a Publisher that, when it emits an item, causes another window to be created
        +
        closingIndicator - a Function that produces a Publisher for every window created. When this Publisher + emits an item, the associated window is closed and emitted
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if openingIndicator or closingIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=ERROR)
+ @SchedulerSupport(value="none")
+public final <U,V> @NonNull Flowable<Flowable<T>> window(@NonNull Publisher<U> openingIndicator,
+        @NonNull Function<? super U,? extends Publisher<V>> closingIndicator,
+        int bufferSize)
        +
        Returns a Flowable that emits windows of items it collects from the current Flowable. The resulting + Flowable emits windows that contain those items emitted by the current Flowable between the time when + the windowOpenings Publisher emits an item and when the Publisher returned by + closingSelector emits an item. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Backpressure:
        +
        The outer Publisher of this operator doesn't support backpressure because the emission of new + inner Publishers are controlled by the windowOpenings Publisher. + The inner Publishers honor backpressure and buffer everything until the associated closing + Publisher signals or completes.
        +
        Scheduler:
        +
        This version of window does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the element type of the window-opening Publisher
        +
        V - the element type of the window-closing Publishers
        +
        Parameters:
        +
        openingIndicator - a Publisher that, when it emits an item, causes another window to be created
        +
        closingIndicator - a Function that produces a Publisher for every window created. When this Publisher + emits an item, the associated window is closed and emitted
        +
        bufferSize - the capacity hint for the buffer in the inner windows
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if openingIndicator or closingIndicator is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        withLatestFrom

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public final <U,R> @NonNull Flowable<R> withLatestFrom(@NonNull Publisher<? extends U> other,
+        @NonNull BiFunction<? super T,? super U,? extends R> combiner)
        +
        Merges the specified Publisher into the current Flowable sequence by using the resultSelector + function only when the current Flowable (this instance) emits an item. + +

        Note that this operator doesn't emit anything until the other source has produced at + least one value. The resulting emission only happens when the current Flowable emits (and + not when the other source emits, unlike combineLatest). + If the other source doesn't produce any value and just completes, the sequence is completed immediately. + If the upstream completes before the other source has produced at least one value, the sequence completes + without emission. +

        + + +

        +
        Backpressure:
        +
        The operator is a pass-through for backpressure: the backpressure support + depends on the upstream and downstream's backpressure behavior. The other Publisher + is consumed in an unbounded fashion.
        +
        Scheduler:
        +
        This operator, by default, doesn't run any particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the element type of the other Publisher
        +
        R - the result type of the combination
        +
        Parameters:
        +
        other - the other Publisher
        +
        combiner - the function to call when the current Flowable emits an item and the other Publisher has already + emitted an item, to generate the item to be emitted by the resulting Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if other or combiner is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        withLatestFrom

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public final <T1,T2,R> @NonNull Flowable<R> withLatestFrom(@NonNull Publisher<T1> source1,
+        @NonNull Publisher<T2> source2,
+        @NonNull Function3<? super T,? super T1,? super T2,R> combiner)
        +
        Combines the value emission from the current Flowable with the latest emissions from the + other Publishers via a function to produce the output item. + +

        Note that this operator doesn't emit anything until all other sources have produced at + least one value. The resulting emission only happens when the current Flowable emits (and + not when any of the other sources emit, unlike combineLatest). + If a source doesn't produce any value and just completes, the sequence is completed immediately. + If the upstream completes before all other sources have produced at least one value, the sequence completes + without emission. + +

        +
        Backpressure:
        +
        This operator is a pass-through for backpressure behavior between the current Flowable + and the downstream Subscriber. The other Publishers are consumed in an unbounded manner.
        +
        Scheduler:
        +
        This operator does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the first other source's value type
        +
        T2 - the second other source's value type
        +
        R - the result value type
        +
        Parameters:
        +
        source1 - the first other Publisher
        +
        source2 - the second other Publisher
        +
        combiner - the function called with an array of values from each participating Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2 or combiner is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        withLatestFrom

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public final <T1,T2,T3,R> @NonNull Flowable<R> withLatestFrom(@NonNull Publisher<T1> source1,
+        @NonNull Publisher<T2> source2,
+        @NonNull Publisher<T3> source3,
+        @NonNull Function4<? super T,? super T1,? super T2,? super T3,R> combiner)
        +
        Combines the value emission from the current Flowable with the latest emissions from the + other Publishers via a function to produce the output item. + +

        Note that this operator doesn't emit anything until all other sources have produced at + least one value. The resulting emission only happens when the current Flowable emits (and + not when any of the other sources emit, unlike combineLatest). + If a source doesn't produce any value and just completes, the sequence is completed immediately. + If the upstream completes before all other sources have produced at least one value, the sequence completes + without emission. + +

        +
        Backpressure:
        +
        This operator is a pass-through for backpressure behavior between the current Flowable + and the downstream Subscriber. The other Publishers are consumed in an unbounded manner.
        +
        Scheduler:
        +
        This operator does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the first other source's value type
        +
        T2 - the second other source's value type
        +
        T3 - the third other source's value type
        +
        R - the result value type
        +
        Parameters:
        +
        source1 - the first other Publisher
        +
        source2 - the second other Publisher
        +
        source3 - the third other Publisher
        +
        combiner - the function called with an array of values from each participating Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3 or combiner is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        withLatestFrom

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public final <T1,T2,T3,T4,R> @NonNull Flowable<R> withLatestFrom(@NonNull Publisher<T1> source1,
+        @NonNull Publisher<T2> source2,
+        @NonNull Publisher<T3> source3,
+        @NonNull Publisher<T4> source4,
+        @NonNull Function5<? super T,? super T1,? super T2,? super T3,? super T4,R> combiner)
        +
        Combines the value emission from the current Flowable with the latest emissions from the + other Publishers via a function to produce the output item. + +

        Note that this operator doesn't emit anything until all other sources have produced at + least one value. The resulting emission only happens when the current Flowable emits (and + not when any of the other sources emit, unlike combineLatest). + If a source doesn't produce any value and just completes, the sequence is completed immediately. + If the upstream completes before all other sources have produced at least one value, the sequence completes + without emission. + +

        +
        Backpressure:
        +
        This operator is a pass-through for backpressure behavior between the current Flowable + and the downstream Subscriber. The other Publishers are consumed in an unbounded manner.
        +
        Scheduler:
        +
        This operator does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the first other source's value type
        +
        T2 - the second other source's value type
        +
        T3 - the third other source's value type
        +
        T4 - the fourth other source's value type
        +
        R - the result value type
        +
        Parameters:
        +
        source1 - the first other Publisher
        +
        source2 - the second other Publisher
        +
        source3 - the third other Publisher
        +
        source4 - the fourth other Publisher
        +
        combiner - the function called with an array of values from each participating Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4 or combiner is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        withLatestFrom

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> withLatestFrom(@NonNull Publisher<?>[] others,
+        @NonNull Function<? super Object[],R> combiner)
        +
        Combines the value emission from the current Flowable with the latest emissions from the + other Publishers via a function to produce the output item. + +

        Note that this operator doesn't emit anything until all other sources have produced at + least one value. The resulting emission only happens when the current Flowable emits (and + not when any of the other sources emit, unlike combineLatest). + If a source doesn't produce any value and just completes, the sequence is completed immediately. + If the upstream completes before all other sources have produced at least one value, the sequence completes + without emission. + +

        +
        Backpressure:
        +
        This operator is a pass-through for backpressure behavior between the current Flowable + and the downstream Subscriber. The other Publishers are consumed in an unbounded manner.
        +
        Scheduler:
        +
        This operator does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        others - the array of other sources
        +
        combiner - the function called with an array of values from each participating Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if others or combiner is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        withLatestFrom

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Flowable<R> withLatestFrom(@NonNull Iterable<? extends Publisher<?>> others,
+        @NonNull Function<? super Object[],R> combiner)
        +
        Combines the value emission from the current Flowable with the latest emissions from the + other Publishers via a function to produce the output item. + +

        Note that this operator doesn't emit anything until all other sources have produced at + least one value. The resulting emission only happens when the current Flowable emits (and + not when any of the other sources emit, unlike combineLatest). + If a source doesn't produce any value and just completes, the sequence is completed immediately. + If the upstream completes before all other sources have produced at least one value, the sequence completes + without emission. + +

        +
        Backpressure:
        +
        This operator is a pass-through for backpressure behavior between the current Flowable + and the downstream Subscriber. The other Publishers are consumed in an unbounded manner.
        +
        Scheduler:
        +
        This operator does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        others - the iterable of other sources
        +
        combiner - the function called with an array of values from each participating Publisher
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if others or combiner is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        zipWith

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <U,R> @NonNull Flowable<R> zipWith(@NonNull Iterable<U> other,
+        @NonNull BiFunction<? super T,? super U,? extends R> zipper)
        +
        Returns a Flowable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Flowable and a specified Iterable sequence. +

        + +

        + Note that the other Iterable is evaluated as items are observed from the current Flowable; it is + not pre-consumed. This allows you to zip infinite streams on either side. +

        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zipWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items in the other Iterable
        +
        R - the type of items emitted by the resulting Flowable
        +
        Parameters:
        +
        other - the Iterable sequence
        +
        zipper - a function that combines the pairs of items from the current Flowable and the Iterable to generate + the items to be emitted by the resulting Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if other or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zipWith

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <U,R> @NonNull Flowable<R> zipWith(@NonNull Publisher<? extends U> other,
+        @NonNull BiFunction<? super T,? super U,? extends R> zipper)
        +
        Returns a Flowable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Flowable and another specified Publisher. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        range(1, 5).doOnComplete(action1).zipWith(range(6, 5).doOnComplete(action2), (a, b) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +

        + +

        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zipWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the other Publisher
        +
        R - the type of items emitted by the resulting Flowable
        +
        Parameters:
        +
        other - the other Publisher
        +
        zipper - a function that combines the pairs of items from the two Publishers to generate the items to + be emitted by the resulting Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if other or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zipWith

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Flowable<R> zipWith(@NonNull Publisher<? extends U> other,
+        @NonNull BiFunction<? super T,? super U,? extends R> zipper,
+        boolean delayError)
        +
        Returns a Flowable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Flowable and another specified Publisher. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        range(1, 5).doOnComplete(action1).zipWith(range(6, 5).doOnComplete(action2), (a, b) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +

        + +

        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zipWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the other Publisher
        +
        R - the type of items emitted by the resulting Flowable
        +
        Parameters:
        +
        other - the other Publisher
        +
        zipper - a function that combines the pairs of items from the two Publishers to generate the items to + be emitted by the resulting Flowable
        +
        delayError - if true, errors from the current Flowable or the other Publisher is delayed until both terminate
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if other or zipper is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zipWith

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Flowable<R> zipWith(@NonNull Publisher<? extends U> other,
+        @NonNull BiFunction<? super T,? super U,? extends R> zipper,
+        boolean delayError,
+        int bufferSize)
        +
        Returns a Flowable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Flowable and another specified Publisher. +

        + The operator subscribes to its sources in the order they are specified and completes eagerly if + one of the sources is shorter than the rest while canceling the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will cancel B immediately. For example: + 

        range(1, 5).doOnComplete(action1).zipWith(range(6, 5).doOnComplete(action2), (a, b) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnCancel(Action) as well or use using() to do cleanup in case of completion + or cancellation. +

        + +

        +
        Backpressure:
        +
        The operator expects backpressure from the sources and honors backpressure from the downstream. + (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use + one of the onBackpressureX to handle similar, backpressure-ignoring sources.
        +
        Scheduler:
        +
        zipWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the other Publisher
        +
        R - the type of items emitted by the resulting Flowable
        +
        Parameters:
        +
        other - the other Publisher
        +
        zipper - a function that combines the pairs of items from the two Publishers to generate the items to + be emitted by the resulting Flowable
        +
        bufferSize - the capacity hint for the buffer in the inner windows
        +
        delayError - if true, errors from the current Flowable or the other Publisher is delayed until both terminate
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if other or zipper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        test

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull TestSubscriber<T> test(long initialRequest,
+        boolean cancel)
        +
        Creates a TestSubscriber with the given initial request amount, + optionally cancels it before the subscription and subscribes + it to this Flowable. +
        +
        Backpressure:
        +
        The returned TestSubscriber requests the given initialRequest amount upfront.
        +
        Scheduler:
        +
        test does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        initialRequest - the initial request amount, positive
        +
        cancel - should the TestSubscriber be canceled before the subscription?
        +
        Returns:
        +
        the new TestSubscriber instance
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        fromOptional

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> fromOptional(@NonNull Optional<T> optional)
        +
        Converts the existing value of the provided optional into a just(Object) + or an empty optional into an empty() Flowable instance. +

        + +

        + Note that the operator takes an already instantiated optional reference and does not + by any means create this original optional. If the optional is to be created per + consumer upon subscription, use defer(Supplier) around fromOptional: + 

        
+ Flowable.defer(() -> Flowable.fromOptional(createOptional()));
+
        +
        +
        Backpressure:
        +
        The returned Flowable supports backpressure.
        +
        Scheduler:
        +
        fromOptional does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the optional value
        +
        Parameters:
        +
        optional - the optional value to convert into a Flowable
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if optional is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        just(Object), +empty()
        +
        +
        • +
      + + + +
        +
      • +

        fromCompletionStage

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> fromCompletionStage(@NonNull CompletionStage<T> stage)
        +
        Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation. +

        + +

        + Note that the operator takes an already instantiated, running or terminated CompletionStage. + If the CompletionStage is to be created per consumer upon subscription, use defer(Supplier) + around fromCompletionStage: + 

        
+ Flowable.defer(() -> Flowable.fromCompletionStage(createCompletionStage()));
+
        +

        + If the CompletionStage completes with null, a NullPointerException is signaled. +

        + Canceling the flow can't cancel the execution of the CompletionStage because CompletionStage + itself doesn't support cancellation. Instead, the operator detaches from the CompletionStage. +

        +
        Backpressure:
        +
        The returned Flowable supports backpressure and caches the completion value until the + downstream is ready to receive it.
        +
        Scheduler:
        +
        fromCompletionStage does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the CompletionStage
        +
        Parameters:
        +
        stage - the CompletionStage to convert to Flowable and signal its terminal value or error
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if stage is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        fromStream

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> fromStream(@NonNull Stream<T> stream)
        +
        Converts a Stream into a finite Flowable and emits its items in the sequence. +

        + +

        + The operator closes the Stream upon cancellation and when it terminates. Any exceptions raised when + closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). + If a Stream should not be closed, turn it into an Iterable and use fromIterable(Iterable): + 

        
+ Stream<T> stream = ...
+ Flowable.fromIterable(stream::iterator);
+
        +

        + Note that Streams can be consumed only once; any subsequent attempt to consume a Stream + will result in an IllegalStateException. +

        + Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): + 

        
+ IntStream intStream = IntStream.rangeClosed(1, 10);
+ Flowable.fromStream(intStream.boxed());
+
        +

        + Stream does not support concurrent usage so creating and/or consuming the same instance multiple times + from multiple threads can lead to undefined behavior. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and iterates the given Stream + on demand (i.e., when requested).
        +
        Scheduler:
        +
        fromStream does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the source Stream
        +
        Parameters:
        +
        stream - the Stream of values to emit
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if stream is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        fromIterable(Iterable)
        +
        +
        • +
      + + + +
        +
      • +

        mapOptional

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper)
        +
        Maps each upstream value into an Optional and emits the contained item if not empty. +

        + + +

        +
        Backpressure:
        +
        The operator is a pass-through for downstream requests but issues request(1) whenever the + mapped Optional is empty.
        +
        Scheduler:
        +
        mapOptional does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the non-null output type
        +
        Parameters:
        +
        mapper - the function that receives the upstream item and should return a non-empty Optional + to emit as the output or an empty Optional to skip to the next upstream value
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        map(Function), +filter(Predicate)
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        blockingStream

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Stream<T> blockingStream()
        +
        Creates a sequential Stream to consume or process this Flowable in a blocking manner via + the Java Stream API. +

        + +

        + Cancellation of the upstream is done via BaseStream.close(), therefore, it is strongly recommended the + consumption is performed within a try-with-resources construct: + 

        
+ Flowable<Integer> source = Flowable.range(1, 10)
+        .subscribeOn(Schedulers.computation());
+
+ try (Stream<Integer> stream = source.blockingStream()) {
+     stream.limit(3).forEach(System.out::println);
+ }
+
        +
        +
        Backpressure:
        +
        The operator requests bufferSize() amount upfront and 75% of it after each 75% of the amount received.
        +
        Scheduler:
        +
        blockingStream does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Stream instance
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        blockingStream(int)
        +
        +
        • +
      + + + +
        +
      • +

        blockingStream

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Stream<T> blockingStream(int prefetch)
        +
        Creates a sequential Stream to consume or process this Flowable in a blocking manner via + the Java Stream API. +

        + +

        + Cancellation of the upstream is done via BaseStream.close(), therefore, it is strongly recommended the + consumption is performed within a try-with-resources construct: + 

        
+ Flowable<Integer> source = Flowable.range(1, 10)
+        .subscribeOn(Schedulers.computation());
+
+ try (Stream<Integer> stream = source.blockingStream(4)) {
+     stream.limit(3).forEach(System.out::println);
+ }
+
        +
        +
        Backpressure:
        +
        The operator requests the given prefetch amount upfront and 75% of it after each 75% of the amount received.
        +
        Scheduler:
        +
        blockingStream does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        prefetch - the number of items to request from the upstream to limit the number of + in-flight items and item generation.
        +
        Returns:
        +
        the new Stream instance
        +
        Throws:
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatMapStream

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> concatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper)
        +
        Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion. +

        + +

        + Due to the blocking and sequential nature of Java Streams, the streams are mapped and consumed in a sequential fashion + without interleaving (unlike a more general flatMap(Function)). Therefore, flatMapStream and + concatMapStream are identical operators and are provided as aliases. +

        + The operator closes the Stream upon cancellation and when it terminates. Any exceptions raised when + closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). + If a Stream should not be closed, turn it into an Iterable and use concatMapIterable(Function): + 

        
+ source.concatMapIterable(v -> createStream(v)::iterator);
+
        +

        + Note that Streams can be consumed only once; any subsequent attempt to consume a Stream + will result in an IllegalStateException. +

        + Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): + 

        
+ source.concatMapStream(v -> IntStream.rangeClosed(v + 1, v + 10).boxed());
+
        +

        + Stream does not support concurrent usage so creating and/or consuming the same instance multiple times + from multiple threads can lead to undefined behavior. +

        +
        Backpressure:
        +
        The operator honors the downstream backpressure and consumes the inner stream only on demand. The operator + prefetches bufferSize() items of the upstream (then 75% of it after the 75% received) + and caches them until they are ready to be mapped into Streams + after the current Stream has been consumed.
        +
        Scheduler:
        +
        concatMapStream does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the Streams and the result
        +
        Parameters:
        +
        mapper - the function that receives an upstream item and should return a Stream whose elements + will be emitted to the downstream
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        concatMap(Function), +concatMapIterable(Function), +concatMapStream(Function, int)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapStream

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> concatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper,
+        int prefetch)
        +
        Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion. +

        + +

        + Due to the blocking and sequential nature of Java Streams, the streams are mapped and consumed in a sequential fashion + without interleaving (unlike a more general flatMap(Function)). Therefore, flatMapStream and + concatMapStream are identical operators and are provided as aliases. +

        + The operator closes the Stream upon cancellation and when it terminates. Any exceptions raised when + closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). + If a Stream should not be closed, turn it into an Iterable and use concatMapIterable(Function, int): + 

        
+ source.concatMapIterable(v -> createStream(v)::iterator, 32);
+
        +

        + Note that Streams can be consumed only once; any subsequent attempt to consume a Stream + will result in an IllegalStateException. +

        + Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): + 

        
+ source.concatMapStream(v -> IntStream.rangeClosed(v + 1, v + 10).boxed(), 32);
+
        +

        + Stream does not support concurrent usage so creating and/or consuming the same instance multiple times + from multiple threads can lead to undefined behavior. +

        +
        Backpressure:
        +
        The operator honors the downstream backpressure and consumes the inner stream only on demand. The operator + prefetches the given amount of upstream items and caches them until they are ready to be mapped into Streams + after the current Stream has been consumed.
        +
        Scheduler:
        +
        concatMapStream does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the Streams and the result
        +
        Parameters:
        +
        mapper - the function that receives an upstream item and should return a Stream whose elements + will be emitted to the downstream
        +
        prefetch - the number of upstream items to request upfront, then 75% of this amount after each 75% upstream items received
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        concatMap(Function, int), +concatMapIterable(Function, int), +flatMapStream(Function, int)
        +
        +
        • +
      + + + +
        +
      • +

        flatMapStream

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> flatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper)
        +
        Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion. +

        + +

        + Due to the blocking and sequential nature of Java Streams, the streams are mapped and consumed in a sequential fashion + without interleaving (unlike a more general flatMap(Function)). Therefore, flatMapStream and + concatMapStream are identical operators and are provided as aliases. +

        + The operator closes the Stream upon cancellation and when it terminates. Any exceptions raised when + closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). + If a Stream should not be closed, turn it into an Iterable and use flatMapIterable(Function): + 

        
+ source.flatMapIterable(v -> createStream(v)::iterator);
+
        +

        + Note that Streams can be consumed only once; any subsequent attempt to consume a Stream + will result in an IllegalStateException. +

        + Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): + 

        
+ source.flatMapStream(v -> IntStream.rangeClosed(v + 1, v + 10).boxed());
+
        +

        + Stream does not support concurrent usage so creating and/or consuming the same instance multiple times + from multiple threads can lead to undefined behavior. +

        +
        Backpressure:
        +
        The operator honors the downstream backpressure and consumes the inner stream only on demand. The operator + prefetches bufferSize() items of the upstream (then 75% of it after the 75% received) + and caches them until they are ready to be mapped into Streams + after the current Stream has been consumed.
        +
        Scheduler:
        +
        flatMapStream does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the Streams and the result
        +
        Parameters:
        +
        mapper - the function that receives an upstream item and should return a Stream whose elements + will be emitted to the downstream
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        flatMap(Function), +flatMapIterable(Function), +flatMapStream(Function, int)
        +
        +
        • +
      + + + +
        +
      • +

        flatMapStream

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Flowable<R> flatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper,
+        int prefetch)
        +
        Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion. +

        + +

        + Due to the blocking and sequential nature of Java Streams, the streams are mapped and consumed in a sequential fashion + without interleaving (unlike a more general flatMap(Function)). Therefore, flatMapStream and + concatMapStream are identical operators and are provided as aliases. +

        + The operator closes the Stream upon cancellation and when it terminates. Any exceptions raised when + closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). + If a Stream should not be closed, turn it into an Iterable and use flatMapIterable(Function, int): + 

        
+ source.flatMapIterable(v -> createStream(v)::iterator, 32);
+
        +

        + Note that Streams can be consumed only once; any subsequent attempt to consume a Stream + will result in an IllegalStateException. +

        + Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): + 

        
+ source.flatMapStream(v -> IntStream.rangeClosed(v + 1, v + 10).boxed(), 32);
+
        +

        + Stream does not support concurrent usage so creating and/or consuming the same instance multiple times + from multiple threads can lead to undefined behavior. +

        +
        Backpressure:
        +
        The operator honors the downstream backpressure and consumes the inner stream only on demand. The operator + prefetches the given amount of upstream items and caches them until they are ready to be mapped into Streams + after the current Stream has been consumed.
        +
        Scheduler:
        +
        flatMapStream does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the Streams and the result
        +
        Parameters:
        +
        mapper - the function that receives an upstream item and should return a Stream whose elements + will be emitted to the downstream
        +
        prefetch - the number of upstream items to request upfront, then 75% of this amount after each 75% upstream items received
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        flatMap(Function, int), +flatMapIterable(Function, int), +concatMapStream(Function, int)
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableConverter.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableConverter.html new file mode 100644 index 0000000000..7862e4aeb6 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableConverter.html @@ -0,0 +1,245 @@ + + + + + +FlowableConverter (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface FlowableConverter<T,R>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the upstream type
    +
    R - the output type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface FlowableConverter<T,R>
    +
    Convenience interface and callback used by the Flowable.to(io.reactivex.rxjava3.core.FlowableConverter<T, ? extends R>) operator to turn a Flowable into another + value fluently. +

    History: 2.1.7 - experimental

    +
    +
    Since:
    +
    2.2
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        apply

        +
        R apply(@NonNull
+        @NonNull Flowable<T> upstream)
        +
        Applies a function to the upstream Flowable and returns a converted value of type R.
        +
        +
        Parameters:
        +
        upstream - the upstream Flowable instance
        +
        Returns:
        +
        the converted value
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableEmitter.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableEmitter.html new file mode 100644 index 0000000000..29b0d88d27 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableEmitter.html @@ -0,0 +1,397 @@ + + + + + +FlowableEmitter (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface FlowableEmitter<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type to emit
    +
    +
    +
    All Superinterfaces:
    +
    Emitter<T>
    +
    +
    +
    +
    public interface FlowableEmitter<T>
+extends Emitter<T>
    +
    Abstraction over a Reactive Streams Subscriber that allows associating + a resource with it and exposes the current number of downstream + requested amount. +

    + The Emitter.onNext(Object), Emitter.onError(Throwable), tryOnError(Throwable) + and Emitter.onComplete() methods should be called in a sequential manner, just like + the Subscriber's methods. + Use the FlowableEmitter the serialize() method returns instead of the original + FlowableEmitter instance provided by the generator routine if you want to ensure this. + The other methods are thread-safe. +

    + The emitter allows the registration of a single resource, in the form of a Disposable + or Cancellable via setDisposable(Disposable) or setCancellable(Cancellable) + respectively. The emitter implementations will dispose/cancel this instance when the + downstream cancels the flow or after the event generator logic calls Emitter.onError(Throwable), + Emitter.onComplete() or when tryOnError(Throwable) succeeds. +

    + Only one Disposable or Cancellable object can be associated with the emitter at + a time. Calling either set method will dispose/cancel any previous object. If there + is a need for handling multiple resources, one can create a CompositeDisposable + and associate that with the emitter instead. +

    + The Cancellable is logically equivalent to Disposable but allows using cleanup logic that can + throw a checked exception (such as many close() methods on Java IO components). Since + the release of resources happens after the terminal events have been delivered or the sequence gets + cancelled, exceptions throw within Cancellable are routed to the global error handler via + RxJavaPlugins.onError(Throwable).

    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        setDisposable

        +
        void setDisposable(@Nullable
+                   @Nullable Disposable d)
        +
        Sets a Disposable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled. +

        This method is thread-safe.

        +
        +
        Parameters:
        +
        d - the disposable, null is allowed
        +
        +
        • +
      + + + +
        +
      • +

        setCancellable

        +
        void setCancellable(@Nullable
+                    @Nullable Cancellable c)
        +
        Sets a Cancellable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled. +

        This method is thread-safe.

        +
        +
        Parameters:
        +
        c - the Cancellable resource, null is allowed
        +
        +
        • +
      + + + +
        +
      • +

        requested

        +
        long requested()
        +
        The current outstanding request amount. +

        This method is thread-safe.

        +
        +
        Returns:
        +
        the current outstanding request amount
        +
        +
        • +
      + + + +
        +
      • +

        isCancelled

        +
        boolean isCancelled()
        +
        Returns true if the downstream cancelled the sequence or the + emitter was terminated via Emitter.onError(Throwable), Emitter.onComplete() or a + successful tryOnError(Throwable). +

        This method is thread-safe.

        +
        +
        Returns:
        +
        true if the downstream cancelled the sequence or the emitter was terminated
        +
        +
        • +
      + + + + + + + +
        +
      • +

        tryOnError

        +
        boolean tryOnError(@NonNull
+                   @NonNull Throwable t)
        +
        Attempts to emit the specified Throwable error if the downstream + hasn't cancelled the sequence or is otherwise terminated, returning false + if the emission is not allowed to happen due to lifecycle restrictions. +

        + Unlike Emitter.onError(Throwable), the RxjavaPlugins.onError + is not called if the error could not be delivered. +

        History: 2.1.1 - experimental

        +
        +
        Parameters:
        +
        t - the throwable error to signal if possible
        +
        Returns:
        +
        true if successful, false if the downstream is not able to accept further + events
        +
        Since:
        +
        2.2
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableOnSubscribe.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableOnSubscribe.html new file mode 100644 index 0000000000..15a1229185 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableOnSubscribe.html @@ -0,0 +1,241 @@ + + + + + +FlowableOnSubscribe (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface FlowableOnSubscribe<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type pushed
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface FlowableOnSubscribe<T>
    +
    A functional interface that has a subscribe() method that receives + a FlowableEmitter instance that allows pushing + events in a backpressure-safe and cancellation-safe manner.
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableOperator.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableOperator.html new file mode 100644 index 0000000000..d105ada7f4 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableOperator.html @@ -0,0 +1,243 @@ + + + + + +FlowableOperator (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface FlowableOperator<Downstream,Upstream>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    Downstream - the value type of the downstream
    +
    Upstream - the value type of the upstream
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface FlowableOperator<Downstream,Upstream>
    +
    Interface to map/wrap a downstream Subscriber to an upstream Subscriber.
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableSubscriber.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableSubscriber.html new file mode 100644 index 0000000000..9dc5a32139 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableSubscriber.html @@ -0,0 +1,268 @@ + + + + + +FlowableSubscriber (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface FlowableSubscriber<T>

+
+
+
+ +
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableTransformer.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableTransformer.html new file mode 100644 index 0000000000..ff839e2711 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/FlowableTransformer.html @@ -0,0 +1,242 @@ + + + + + +FlowableTransformer (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface FlowableTransformer<Upstream,Downstream>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    Upstream - the upstream value type
    +
    Downstream - the downstream value type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface FlowableTransformer<Upstream,Downstream>
    +
    Interface to compose Flowables.
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Maybe.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Maybe.html new file mode 100644 index 0000000000..9e5652e34f --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Maybe.html @@ -0,0 +1,9347 @@ + + + + + +Maybe (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Class Maybe<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    All Implemented Interfaces:
    +
    MaybeSource<T>
    +
    +
    +
    Direct Known Subclasses:
    +
    MaybeSubject
    +
    +
    +
    +
    public abstract class Maybe<T>
+extends Object
+implements MaybeSource<T>
    +
    The Maybe class represents a deferred computation and emission of a single value, no value at all or an exception. +

    + The Maybe class implements the MaybeSource base interface and the default consumer + type it interacts with is the MaybeObserver via the subscribe(MaybeObserver) method. +

    + The Maybe operates with the following sequential protocol: + 

    
+     onSubscribe (onSuccess | onError | onComplete)?
+
    +

    + Note that onSuccess, onError and onComplete are mutually exclusive events; unlike Observable, + onSuccess is never followed by onError or onComplete. +

    + Like Observable, a running Maybe can be stopped through the Disposable instance + provided to consumers through MaybeObserver.onSubscribe(io.reactivex.rxjava3.disposables.Disposable). +

    + Like an Observable, a Maybe is lazy, can be either "hot" or "cold", synchronous or + asynchronous. Maybe instances returned by the methods of this class are cold + and there is a standard hot implementation in the form of a subject: + MaybeSubject. +

    + The documentation for this class makes use of marble diagrams. The following legend explains these diagrams: +

    + +

    + See Flowable or Observable for the + implementation of the Reactive Pattern for a stream or vector of values. +

    + Example: + 

    
+ Disposable d = Maybe.just("Hello World")
+    .delay(10, TimeUnit.SECONDS, Schedulers.io())
+    .subscribeWith(new DisposableMaybeObserver<String>() {
+        @Override
+        public void onStart() {
+            System.out.println("Started");
+        }
+
+        @Override
+        public void onSuccess(String value) {
+            System.out.println("Success: " + value);
+        }
+
+        @Override
+        public void onError(Throwable error) {
+            error.printStackTrace();
+        }
+
+        @Override
+        public void onComplete() {
+            System.out.println("Done!");
+        }
+    });
+ 
+ Thread.sleep(5000);
+ 
+ d.dispose();
+
    +

    + Note that by design, subscriptions via subscribe(MaybeObserver) can't be disposed + from the outside (hence the + void return of the subscribe(MaybeObserver) method) and it is the + responsibility of the implementor of the MaybeObserver to allow this to happen. + RxJava supports such usage with the standard + DisposableMaybeObserver instance. + For convenience, the subscribeWith(MaybeObserver) method is provided as well to + allow working with a MaybeObserver (or subclass) instance to be applied with in + a fluent manner (such as in the example above).

    +
    +
    Since:
    +
    2.0
    +
    See Also:
    +
    DisposableMaybeObserver
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Maybe

        +
        public Maybe()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        concatArrayEager

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+ @SafeVarargs
+public static <T> @NonNull Flowable<T> concatArrayEager(@NonNull MaybeSource<? extends T>... sources)
        +
        Concatenates a sequence of MaybeSource eagerly into a Flowable sequence. +

        + Eager concatenation means that once an observer subscribes, this operator subscribes to all of the + source MaybeSources. The operator buffers the value emitted by these MaybeSources and then drains them + in order, each one after the previous one completes. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of MaybeSources that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        +
        • +
      + + + +
        +
      • +

        concatArrayEagerDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+ @SafeVarargs
+public static <T> @NonNull Flowable<T> concatArrayEagerDelayError(@NonNull MaybeSource<? extends T>... sources)
        +
        Concatenates a sequence of MaybeSource eagerly into a Flowable sequence. +

        + Eager concatenation means that once an observer subscribes, this operator subscribes to all of the + source MaybeSources. The operator buffers the value emitted by these MaybeSources and then drains them + in order, each one after the previous one completes. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of MaybeSources that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> concatDelayError(@NonNull Iterable<? extends MaybeSource<? extends T>> sources)
        +
        Concatenates the Iterable sequence of MaybeSources into a single sequence by subscribing to each MaybeSource, + one after the other, one at a time and delays any errors till the all inner MaybeSources terminate + as a Flowable sequence. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        concatDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable sequence of MaybeSources
        +
        Returns:
        +
        the new Flowable with the concatenating behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        +
        • +
      + + + +
        +
      • +

        concatDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatDelayError(@NonNull Publisher<? extends MaybeSource<? extends T>> sources)
        +
        Concatenates the Publisher sequence of MaybeSources into a single sequence by subscribing to each inner MaybeSource, + one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate + as a Flowable sequence. +

        + +

        +
        Backpressure:
        +
        concatDelayError fully supports backpressure.
        +
        Scheduler:
        +
        concatDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Publisher sequence of MaybeSources
        +
        Returns:
        +
        the new Flowable with the concatenating behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        +
        • +
      + + + +
        +
      • +

        concatDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatDelayError(@NonNull Publisher<? extends MaybeSource<? extends T>> sources,
+        int prefetch)
        +
        Concatenates the Publisher sequence of MaybeSources into a single sequence by subscribing to each inner MaybeSource, + one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate + as a Flowable sequence. +

        + +

        +
        Backpressure:
        +
        concatDelayError fully supports backpressure.
        +
        Scheduler:
        +
        concatDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Publisher sequence of MaybeSources
        +
        prefetch - The number of upstream items to prefetch so that fresh items are + ready to be mapped when a previous MaybeSource terminates. + The operator replenishes after half of the prefetch amount has been consumed + and turned into MaybeSources.
        +
        Returns:
        +
        the new Flowable with the concatenating behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatEager(@NonNull Iterable<? extends MaybeSource<? extends T>> sources)
        +
        Concatenates a sequence of MaybeSources eagerly into a Flowable sequence. +

        + +

        + Eager concatenation means that once an observer subscribes, this operator subscribes to all of the + source MaybeSources. The operator buffers the values emitted by these MaybeSources and then drains them + in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of MaybeSource that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatEager(@NonNull Iterable<? extends MaybeSource<? extends T>> sources,
+        int maxConcurrency)
        +
        Concatenates a sequence of MaybeSources eagerly into a Flowable sequence and + runs a limited number of the inner sequences at once. +

        + +

        + Eager concatenation means that once an observer subscribes, this operator subscribes to all of the + source MaybeSources. The operator buffers the values emitted by these MaybeSources and then drains them + in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of MaybeSource that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrently running inner MaybeSources; Integer.MAX_VALUE + is interpreted as all inner MaybeSources can be active at the same time
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatEager(@NonNull Publisher<? extends MaybeSource<? extends T>> sources)
        +
        Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence. +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source MaybeSources as they are observed. The operator buffers the values emitted by these + MaybeSources and then drains them in order, each one after the previous one completes. +

        + +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and the outer Publisher is + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of MaybeSources that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatEager(@NonNull Publisher<? extends MaybeSource<? extends T>> sources,
+        int maxConcurrency)
        +
        Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence, + running at most the given number of inner MaybeSources at once. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source MaybeSources as they are observed. The operator buffers the values emitted by these + MaybeSources and then drains them in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and the outer Publisher is + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of MaybeSources that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrently running inner MaybeSources; Integer.MAX_VALUE + is interpreted as all inner MaybeSources can be active at the same time
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Iterable<? extends MaybeSource<? extends T>> sources)
        +
        Concatenates a sequence of MaybeSources eagerly into a Flowable sequence, + delaying errors until all inner MaybeSources terminate. +

        + +

        + Eager concatenation means that once an observer subscribes, this operator subscribes to all of the + source MaybeSources. The operator buffers the values emitted by these MaybeSources and then drains them + in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of MaybeSource that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Iterable<? extends MaybeSource<? extends T>> sources,
+        int maxConcurrency)
        +
        Concatenates a sequence of MaybeSources eagerly into a Flowable sequence, + delaying errors until all inner MaybeSources terminate and + runs a limited number of inner MaybeSources at once. +

        + +

        + Eager concatenation means that once an observer subscribes, this operator subscribes to all of the + source MaybeSources. The operator buffers the values emitted by these MaybeSources and then drains them + in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of MaybeSource that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrently running inner MaybeSources; Integer.MAX_VALUE + is interpreted as all inner MaybeSources can be active at the same time
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Publisher<? extends MaybeSource<? extends T>> sources)
        +
        Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence, + delaying errors until all the inner and the outer sequence terminate. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source MaybeSources as they are observed. The operator buffers the values emitted by these + MaybeSources and then drains them in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and the outer Publisher is + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of MaybeSources that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Publisher<? extends MaybeSource<? extends T>> sources,
+        int maxConcurrency)
        +
        Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence, + delaying errors until all the inner and the outer sequence terminate and + runs a limited number of the inner MaybeSources at once. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source MaybeSources as they are observed. The operator buffers the values emitted by these + MaybeSources and then drains them in order, each one after the previous one completes. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and the outer Publisher is + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of MaybeSources that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrently running inner MaybeSources; Integer.MAX_VALUE + is interpreted as all inner MaybeSources can be active at the same time
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Maybe<T> create(@NonNull MaybeOnSubscribe<T> onSubscribe)
        +
        Provides an API (via a cold Maybe) that bridges the reactive world with the callback-style world. +

        + +

        + Example: + 

        
+ Maybe.<Event>create(emitter -> {
+     Callback listener = new Callback() {
+         @Override
+         public void onEvent(Event e) {
+             if (e.isNothing()) {
+                 emitter.onComplete();
+             } else {
+                 emitter.onSuccess(e);
+             }
+         }
+
+         @Override
+         public void onFailure(Exception e) {
+             emitter.onError(e);
+         }
+     };
+
+     AutoCloseable c = api.someMethod(listener);
+
+     emitter.setCancellable(c::close);
+
+ });
+
        +

        + Whenever a MaybeObserver subscribes to the returned Maybe, the provided + MaybeOnSubscribe callback is invoked with a fresh instance of a MaybeEmitter + that will interact only with that specific MaybeObserver. If this MaybeObserver + disposes the flow (making MaybeEmitter.isDisposed() return true), + other observers subscribed to the same returned Maybe are not affected. +

        +
        Scheduler:
        +
        create does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        onSubscribe - the emitter that is called when a MaybeObserver subscribes to the returned Maybe
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if onSubscribe is null
        +
        See Also:
        +
        MaybeOnSubscribe, +Cancellable
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        fromCallable

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Maybe<T> fromCallable(@NonNull Callable<? extends T> callable)
        +
        Returns a Maybe that invokes the given Callable for each individual MaybeObserver that + subscribes and emits the resulting non-null item via onSuccess while + considering a null result from the Callable as indication for valueless completion + via onComplete. +

        + +

        + This operator allows you to defer the execution of the given Callable until a MaybeObserver + subscribes to the returned Maybe. In other terms, this source operator evaluates the given + Callable "lazily". +

        + Note that the null handling of this operator differs from the similar source operators in the other + base reactive classes. Those operators signal a NullPointerException if the value returned by their + Callable is null while this fromCallable considers it to indicate the + returned Maybe is empty. +

        +
        Scheduler:
        +
        fromCallable does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        Any non-fatal exception thrown by Callable.call() will be forwarded to onError, + except if the MaybeObserver disposed the subscription in the meantime. In this latter case, + the exception is forwarded to the global error handler via + RxJavaPlugins.onError(Throwable) wrapped into a + UndeliverableException. + Fatal exceptions are rethrown and usually will end up in the executing thread's + Thread.UncaughtExceptionHandler.uncaughtException(Thread, Throwable) handler.
        +
        +
        +
        Type Parameters:
        +
        T - the type of the item emitted by the Maybe.
        +
        Parameters:
        +
        callable - a Callable instance whose execution should be deferred and performed for each individual + MaybeObserver that subscribes to the returned Maybe.
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if callable is null
        +
        See Also:
        +
        defer(Supplier), +fromSupplier(Supplier)
        +
        +
        • +
      + + + +
        +
      • +

        fromFuture

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Maybe<T> fromFuture(@NonNull Future<? extends T> future)
        +
        Converts a Future into a Maybe, treating a null result as an indication of emptiness. +

        + +

        + The operator calls Future.get(), which is a blocking method, on the subscription thread. + It is recommended applying subscribeOn(Scheduler) to move this blocking wait to a + background thread, and if the Scheduler supports it, interrupt the wait when the flow + is disposed. +

        + Unlike 1.x, disposing the Maybe won't cancel the future. If necessary, one can use composition to achieve the + cancellation effect: futureMaybe.doOnDispose(() -> future.cancel(true));. +

        +
        Scheduler:
        +
        fromFuture does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the type of object that the Future returns, and also the type of item to be emitted by + the resulting Maybe
        +
        Parameters:
        +
        future - the source Future
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if future is null
        +
        See Also:
        +
        ReactiveX operators documentation: From, +fromCompletionStage(CompletionStage)
        +
        +
        • +
      + + + +
        +
      • +

        fromFuture

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Maybe<T> fromFuture(@NonNull Future<? extends T> future,
+        long timeout,
+        @NonNull TimeUnit unit)
        +
        Converts a Future into a Maybe, with a timeout on the Future. +

        + +

        + The operator calls Future.get(long, TimeUnit), which is a blocking method, on the subscription thread. + It is recommended applying subscribeOn(Scheduler) to move this blocking wait to a + background thread, and if the Scheduler supports it, interrupt the wait when the flow + is disposed. +

        + Unlike 1.x, disposing the Maybe won't cancel the future. If necessary, one can use composition to achieve the + cancellation effect: futureMaybe.doOnCancel(() -> future.cancel(true));. +

        +
        Scheduler:
        +
        fromFuture does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the type of object that the Future returns, and also the type of item to be emitted by + the resulting Maybe
        +
        Parameters:
        +
        future - the source Future
        +
        timeout - the maximum time to wait before calling get
        +
        unit - the TimeUnit of the timeout argument
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if future or unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: From, +fromCompletionStage(CompletionStage)
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        fromRunnable

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Maybe<T> fromRunnable(@NonNull Runnable run)
        +
        Returns a Maybe instance that runs the given Runnable for each MaybeObserver and + emits either its unchecked exception or simply completes. +

        + +

        + If the code to be wrapped needs to throw a checked or more broader Throwable exception, that + exception has to be converted to an unchecked exception by the wrapped code itself. Alternatively, + use the fromAction(Action) method which allows the wrapped code to throw any Throwable + exception and will signal it to observers as-is. +

        +
        Scheduler:
        +
        fromRunnable does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the Runnable throws an exception, the respective Throwable is + delivered to the downstream via MaybeObserver.onError(Throwable), + except when the downstream has disposed this Maybe source. + In this latter case, the Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) as an UndeliverableException. +
        +
        +
        +
        Type Parameters:
        +
        T - the target type
        +
        Parameters:
        +
        run - the Runnable to run for each MaybeObserver
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if run is null
        +
        See Also:
        +
        fromAction(Action)
        +
        +
        • +
      + + + +
        +
      • +

        fromSupplier

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Maybe<T> fromSupplier(@NonNull Supplier<? extends T> supplier)
        +
        Returns a Maybe that invokes the given Supplier for each individual MaybeObserver that + subscribes and emits the resulting non-null item via onSuccess while + considering a null result from the Supplier as indication for valueless completion + via onComplete. +

        + This operator allows you to defer the execution of the given Supplier until a MaybeObserver + subscribes to the returned Maybe. In other terms, this source operator evaluates the given + Supplier "lazily". +

        + +

        + Note that the null handling of this operator differs from the similar source operators in the other + base reactive classes. Those operators signal a NullPointerException if the value returned by their + Supplier is null while this fromSupplier considers it to indicate the + returned Maybe is empty. +

        +
        Scheduler:
        +
        fromSupplier does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        Any non-fatal exception thrown by Supplier.get() will be forwarded to onError, + except if the MaybeObserver disposed the subscription in the meantime. In this latter case, + the exception is forwarded to the global error handler via + RxJavaPlugins.onError(Throwable) wrapped into a + UndeliverableException. + Fatal exceptions are rethrown and usually will end up in the executing thread's + Thread.UncaughtExceptionHandler.uncaughtException(Thread, Throwable) handler.
        +
        +
        +
        Type Parameters:
        +
        T - the type of the item emitted by the Maybe.
        +
        Parameters:
        +
        supplier - a Supplier instance whose execution should be deferred and performed for each individual + MaybeObserver that subscribes to the returned Maybe.
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if supplier is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        defer(Supplier), +fromCallable(Callable)
        +
        +
        • +
      + + + + + + + + + +
        +
      • +

        merge

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> merge(@NonNull Iterable<? extends MaybeSource<? extends T>> sources)
        +
        Merges an Iterable sequence of MaybeSource instances into a single Flowable sequence, + running all MaybeSources at once. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source MaybeSources signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source MaybeSources are disposed. + If more than one MaybeSource signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been cancelled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(Iterable) to merge sources and terminate only when all source MaybeSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common and resulting value type
        +
        Parameters:
        +
        sources - the Iterable sequence of MaybeSource sources
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        mergeDelayError(Iterable)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> merge(@NonNull Publisher<? extends MaybeSource<? extends T>> sources)
        +
        Merges a Publisher sequence of MaybeSource instances into a single Flowable sequence, + running all MaybeSources at once. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source MaybeSources signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source MaybeSources are disposed. + If more than one MaybeSource signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been cancelled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(Publisher) to merge sources and terminate only when all source MaybeSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common and resulting value type
        +
        Parameters:
        +
        sources - the Flowable sequence of MaybeSource sources
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        mergeDelayError(Publisher)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> merge(@NonNull Publisher<? extends MaybeSource<? extends T>> sources,
+        int maxConcurrency)
        +
        Merges a Publisher sequence of MaybeSource instances into a single Flowable sequence, + running at most maxConcurrency MaybeSources at once. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source MaybeSources signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source MaybeSources are disposed. + If more than one MaybeSource signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been cancelled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(Publisher, int) to merge sources and terminate only when all source MaybeSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common and resulting value type
        +
        Parameters:
        +
        sources - the Flowable sequence of MaybeSource sources
        +
        maxConcurrency - the maximum number of concurrently running MaybeSources
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        See Also:
        +
        mergeDelayError(Publisher, int)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Maybe<T> merge(@NonNull MaybeSource<? extends MaybeSource<? extends T>> source)
        +
        Flattens a MaybeSource that emits a MaybeSource into a single MaybeSource that emits the item + emitted by the nested MaybeSource, without any transformation. +

        + +

        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        The resulting Maybe emits the outer source's or the inner MaybeSource's Throwable as is. + Unlike the other merge() operators, this operator won't and can't produce a CompositeException because there is + only one possibility for the outer or the inner MaybeSource to emit an onError signal. + Therefore, there is no need for a mergeDelayError(MaybeSource<MaybeSource<T>>) operator. +
        +
        +
        +
        Type Parameters:
        +
        T - the value type of the sources and the output
        +
        Parameters:
        +
        source - a MaybeSource that emits a MaybeSource
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if source is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> merge(@NonNull MaybeSource<? extends T> source1,
+        @NonNull MaybeSource<? extends T> source2)
        +
        Flattens two MaybeSources into a single Flowable, without any transformation. +

        + +

        + You can combine items emitted by multiple MaybeSources so that they appear as a single Flowable, by + using the merge method. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source MaybeSources signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source MaybeSources are disposed. + If more than one MaybeSource signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been cancelled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(MaybeSource, MaybeSource) to merge sources and terminate only when all source MaybeSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common value type
        +
        Parameters:
        +
        source1 - a MaybeSource to be merged
        +
        source2 - a MaybeSource to be merged
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1 or source2 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeDelayError(MaybeSource, MaybeSource)
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        mergeArray

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+public static <T> @NonNull Flowable<T> mergeArray(MaybeSource<? extends T>... sources)
        +
        Merges an array of MaybeSource instances into a single Flowable sequence, + running all MaybeSources at once. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        mergeArray does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source MaybeSources signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source MaybeSources are disposed. + If more than one MaybeSource signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been cancelled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeArrayDelayError(MaybeSource...) to merge sources and terminate only when all source MaybeSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common and resulting value type
        +
        Parameters:
        +
        sources - the array sequence of MaybeSource sources
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        mergeArrayDelayError(MaybeSource...)
        +
        +
        • +
      + + + +
        +
      • +

        mergeArrayDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+ @NonNull
+public static <T> @NonNull Flowable<T> mergeArrayDelayError(@NonNull MaybeSource<? extends T>... sources)
        +
        Flattens an array of MaybeSources into one Flowable, in a way that allows a subscriber to receive all + successfully emitted items from each of the source MaybeSources without being interrupted by an error + notification from one of them. +

        + +

        + This behaves like merge(Publisher) except that if any of the merged MaybeSources notify of an + error via onError, mergeArrayDelayError will refrain from propagating that + error notification until all of the merged MaybeSources have finished emitting items. +

        + Even if multiple merged MaybeSources send onError notifications, mergeArrayDelayError will only + invoke the onError method of its subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        mergeArrayDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the array of MaybeSources
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Iterable<? extends MaybeSource<? extends T>> sources)
        +
        Flattens an Iterable sequence of MaybeSources into one Flowable, in a way that allows a subscriber to receive all + successfully emitted items from each of the source MaybeSources without being interrupted by an error + notification from one of them. +

        + +

        + This behaves like merge(Publisher) except that if any of the merged MaybeSources notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged MaybeSources have finished emitting items. +

        + +

        + Even if multiple merged MaybeSources send onError notifications, mergeDelayError will only + invoke the onError method of its subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable of MaybeSources
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Publisher<? extends MaybeSource<? extends T>> sources)
        +
        Flattens a Publisher that emits MaybeSources into one Flowable, in a way that allows a subscriber to + receive all successfully emitted items from all of the source MaybeSources without being interrupted by + an error notification from one of them or even the main Publisher. +

        + +

        + This behaves like merge(Publisher) except that if any of the merged MaybeSources notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged MaybeSources and the main Publisher have finished emitting items. +

        + Even if multiple merged MaybeSources send onError notifications, mergeDelayError will only + invoke the onError method of its subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The outer Publisher is consumed + in unbounded mode (i.e., no backpressure is applied to it).
        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - a Publisher that emits MaybeSources
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Publisher<? extends MaybeSource<? extends T>> sources,
+        int maxConcurrency)
        +
        Flattens a Publisher that emits MaybeSources into one Flowable, in a way that allows a subscriber to + receive all successfully emitted items from all of the source MaybeSources without being interrupted by + an error notification from one of them or even the main Publisher as well as limiting the total number of active MaybeSources. +

        + +

        + This behaves like merge(Publisher, int) except that if any of the merged MaybeSources notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged MaybeSources and the main Publisher have finished emitting items. +

        + Even if multiple merged MaybeSources send onError notifications, mergeDelayError will only + invoke the onError method of its subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream. The outer Publisher is consumed + in unbounded mode (i.e., no backpressure is applied to it).
        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.9 - experimental

        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - a Publisher that emits MaybeSources
        +
        maxConcurrency - the maximum number of active inner MaybeSources to be merged at a time
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull MaybeSource<? extends T> source1,
+        @NonNull MaybeSource<? extends T> source2)
        +
        Flattens two MaybeSources into one Flowable, in a way that allows a subscriber to receive all + successfully emitted items from each of the source MaybeSources without being interrupted by an error + notification from one of them. +

        + +

        + This behaves like merge(MaybeSource, MaybeSource) except that if any of the merged MaybeSources + notify of an error via onError, mergeDelayError will refrain from + propagating that error notification until all of the merged MaybeSources have finished emitting items. +

        + Even if both merged MaybeSources send onError notifications, mergeDelayError will only + invoke the onError method of its subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        source1 - a MaybeSource to be merged
        +
        source2 - a MaybeSource to be merged
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1 or source2 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull MaybeSource<? extends T> source1,
+        @NonNull MaybeSource<? extends T> source2,
+        @NonNull MaybeSource<? extends T> source3)
        +
        Flattens three MaybeSource into one Flowable, in a way that allows a subscriber to receive all + successfully emitted items from all of the source MaybeSources without being interrupted by an error + notification from one of them. +

        + +

        + This behaves like merge(MaybeSource, MaybeSource, MaybeSource) except that if any of the merged + MaybeSources notify of an error via onError, mergeDelayError will refrain + from propagating that error notification until all of the merged MaybeSources have finished emitting + items. +

        + Even if multiple merged MaybeSources send onError notifications, mergeDelayError will only + invoke the onError method of its subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        source1 - a MaybeSource to be merged
        +
        source2 - a MaybeSource to be merged
        +
        source3 - a MaybeSource to be merged
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2 or source3 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        switchOnNextDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> switchOnNextDelayError(@NonNull Publisher<? extends MaybeSource<? extends T>> sources)
        +
        Switches between MaybeSources emitted by the source Publisher whenever + a new MaybeSource is emitted, disposing the previously running MaybeSource, + exposing the success items as a Flowable sequence and delaying all errors from + all of them until all terminate. +

        + +

        +
        Backpressure:
        +
        The sources Publisher is consumed in an unbounded manner (requesting Long.MAX_VALUE). + The returned Flowable respects the backpressure from the downstream.
        +
        Scheduler:
        +
        switchOnNextDelayError does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        The returned Flowable collects all errors emitted by either the sources + Publisher or any inner MaybeSource and emits them as a CompositeException + when all sources terminate. If only one source ever failed, its error is emitted as-is at the end.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the MaybeSources
        +
        Parameters:
        +
        sources - the Publisher sequence of inner MaybeSources to switch between
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        switchOnNext(Publisher), +ReactiveX operators documentation: Switch
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        using

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T,D> @NonNull Maybe<T> using(@NonNull Supplier<? extends D> resourceSupplier,
+        @NonNull Function<? super D,? extends MaybeSource<? extends T>> sourceSupplier,
+        @NonNull Consumer<? super D> resourceCleanup)
        +
        Constructs a Maybe that creates a dependent resource object which is disposed of when the + generated MaybeSource terminates or the downstream calls dispose(). +

        + +

        +
        Scheduler:
        +
        using does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the generated MaybeSource
        +
        D - the type of the resource associated with the output sequence
        +
        Parameters:
        +
        resourceSupplier - the factory function to create a resource object that depends on the Maybe
        +
        sourceSupplier - the factory function to create a MaybeSource
        +
        resourceCleanup - the function that will dispose of the resource
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if resourceSupplier, sourceSupplier or resourceCleanup is null
        +
        See Also:
        +
        ReactiveX operators documentation: Using
        +
        +
        • +
      + + + +
        +
      • +

        using

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T,D> @NonNull Maybe<T> using(@NonNull Supplier<? extends D> resourceSupplier,
+        @NonNull Function<? super D,? extends MaybeSource<? extends T>> sourceSupplier,
+        @NonNull Consumer<? super D> resourceCleanup,
+        boolean eager)
        +
        Constructs a Maybe that creates a dependent resource object which is disposed first ({code eager == true}) + when the generated MaybeSource terminates or the downstream disposes; or after ({code eager == false}). +

        + +

        + Eager disposal is particularly appropriate for a synchronous Maybe that reuses resources. disposeAction will + only be called once per subscription. +

        +
        Scheduler:
        +
        using does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the generated MaybeSource
        +
        D - the type of the resource associated with the output sequence
        +
        Parameters:
        +
        resourceSupplier - the factory function to create a resource object that depends on the Maybe
        +
        sourceSupplier - the factory function to create a MaybeSource
        +
        resourceCleanup - the function that will dispose of the resource
        +
        eager - If true then resource disposal will happen either on a dispose() call before the upstream is disposed + or just before the emission of a terminal event (onSuccess, onComplete or onError). + If false the resource disposal will happen either on a dispose() call after the upstream is disposed + or just after the emission of a terminal event (onSuccess, onComplete or onError).
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if resourceSupplier, sourceSupplier or resourceCleanup is null
        +
        See Also:
        +
        ReactiveX operators documentation: Using
        +
        +
        • +
      + + + + + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T,R> @NonNull Maybe<R> zip(@NonNull Iterable<? extends MaybeSource<? extends T>> sources,
+        @NonNull Function<? super Object[],? extends R> zipper)
        +
        Returns a Maybe that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an Iterable of other MaybeSources. +

        + +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This + also means it is possible some sources may not get subscribed to at all. +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common value type
        +
        R - the zipped result type
        +
        Parameters:
        +
        sources - an Iterable of source MaybeSources
        +
        zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in + an item that will be emitted by the resulting Maybe
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if zipper or sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,R> @NonNull Maybe<R> zip(@NonNull MaybeSource<? extends T1> source1,
+        @NonNull MaybeSource<? extends T2> source2,
+        @NonNull BiFunction<? super T1,? super T2,? extends R> zipper)
        +
        Returns a Maybe that emits the results of a specified combiner function applied to combinations of + two items emitted, in sequence, by two other MaybeSources. +

        + +

        + This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This + also means it is possible some sources may not get subscribed to at all. +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source MaybeSource
        +
        source2 - a second source MaybeSource
        +
        zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results + in an item that will be emitted by the resulting Maybe
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if source1, source2 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,R> @NonNull Maybe<R> zip(@NonNull MaybeSource<? extends T1> source1,
+        @NonNull MaybeSource<? extends T2> source2,
+        @NonNull MaybeSource<? extends T3> source3,
+        @NonNull Function3<? super T1,? super T2,? super T3,? extends R> zipper)
        +
        Returns a Maybe that emits the results of a specified combiner function applied to combinations of + three items emitted, in sequence, by three other MaybeSources. +

        + +

        + This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This + also means it is possible some sources may not get subscribed to at all. +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source MaybeSource
        +
        source2 - a second source MaybeSource
        +
        source3 - a third source MaybeSource
        +
        zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in + an item that will be emitted by the resulting Maybe
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,R> @NonNull Maybe<R> zip(@NonNull MaybeSource<? extends T1> source1,
+        @NonNull MaybeSource<? extends T2> source2,
+        @NonNull MaybeSource<? extends T3> source3,
+        @NonNull MaybeSource<? extends T4> source4,
+        @NonNull Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)
        +
        Returns a Maybe that emits the results of a specified combiner function applied to combinations of + four items emitted, in sequence, by four other MaybeSources. +

        + +

        + This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This + also means it is possible some sources may not get subscribed to at all. +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source MaybeSource
        +
        source2 - a second source MaybeSource
        +
        source3 - a third source MaybeSource
        +
        source4 - a fourth source MaybeSource
        +
        zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in + an item that will be emitted by the resulting Maybe
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,R> @NonNull Maybe<R> zip(@NonNull MaybeSource<? extends T1> source1,
+        @NonNull MaybeSource<? extends T2> source2,
+        @NonNull MaybeSource<? extends T3> source3,
+        @NonNull MaybeSource<? extends T4> source4,
+        @NonNull MaybeSource<? extends T5> source5,
+        @NonNull Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)
        +
        Returns a Maybe that emits the results of a specified combiner function applied to combinations of + five items emitted, in sequence, by five other MaybeSources. +

        + +

        + This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This + also means it is possible some sources may not get subscribed to at all. +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        T5 - the value type of the fifth source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source MaybeSource
        +
        source2 - a second source MaybeSource
        +
        source3 - a third source MaybeSource
        +
        source4 - a fourth source MaybeSource
        +
        source5 - a fifth source MaybeSource
        +
        zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in + an item that will be emitted by the resulting Maybe
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,R> @NonNull Maybe<R> zip(@NonNull MaybeSource<? extends T1> source1,
+        @NonNull MaybeSource<? extends T2> source2,
+        @NonNull MaybeSource<? extends T3> source3,
+        @NonNull MaybeSource<? extends T4> source4,
+        @NonNull MaybeSource<? extends T5> source5,
+        @NonNull MaybeSource<? extends T6> source6,
+        @NonNull Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)
        +
        Returns a Maybe that emits the results of a specified combiner function applied to combinations of + six items emitted, in sequence, by six other MaybeSources. +

        + +

        + This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This + also means it is possible some sources may not get subscribed to at all. +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        T5 - the value type of the fifth source
        +
        T6 - the value type of the sixth source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source MaybeSource
        +
        source2 - a second source MaybeSource
        +
        source3 - a third source MaybeSource
        +
        source4 - a fourth source MaybeSource
        +
        source5 - a fifth source MaybeSource
        +
        source6 - a sixth source MaybeSource
        +
        zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in + an item that will be emitted by the resulting Maybe
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,T7,R> @NonNull Maybe<R> zip(@NonNull MaybeSource<? extends T1> source1,
+        @NonNull MaybeSource<? extends T2> source2,
+        @NonNull MaybeSource<? extends T3> source3,
+        @NonNull MaybeSource<? extends T4> source4,
+        @NonNull MaybeSource<? extends T5> source5,
+        @NonNull MaybeSource<? extends T6> source6,
+        @NonNull MaybeSource<? extends T7> source7,
+        @NonNull Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)
        +
        Returns a Maybe that emits the results of a specified combiner function applied to combinations of + seven items emitted, in sequence, by seven other MaybeSources. +

        + +

        + This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This + also means it is possible some sources may not get subscribed to at all. +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        T5 - the value type of the fifth source
        +
        T6 - the value type of the sixth source
        +
        T7 - the value type of the seventh source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source MaybeSource
        +
        source2 - a second source MaybeSource
        +
        source3 - a third source MaybeSource
        +
        source4 - a fourth source MaybeSource
        +
        source5 - a fifth source MaybeSource
        +
        source6 - a sixth source MaybeSource
        +
        source7 - a seventh source MaybeSource
        +
        zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in + an item that will be emitted by the resulting Maybe
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6, + source7 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,T7,T8,R> @NonNull Maybe<R> zip(@NonNull MaybeSource<? extends T1> source1,
+        @NonNull MaybeSource<? extends T2> source2,
+        @NonNull MaybeSource<? extends T3> source3,
+        @NonNull MaybeSource<? extends T4> source4,
+        @NonNull MaybeSource<? extends T5> source5,
+        @NonNull MaybeSource<? extends T6> source6,
+        @NonNull MaybeSource<? extends T7> source7,
+        @NonNull MaybeSource<? extends T8> source8,
+        @NonNull Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)
        +
        Returns a Maybe that emits the results of a specified combiner function applied to combinations of + eight items emitted, in sequence, by eight other MaybeSources. +

        + +

        + This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This + also means it is possible some sources may not get subscribed to at all. +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        T5 - the value type of the fifth source
        +
        T6 - the value type of the sixth source
        +
        T7 - the value type of the seventh source
        +
        T8 - the value type of the eighth source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source MaybeSource
        +
        source2 - a second source MaybeSource
        +
        source3 - a third source MaybeSource
        +
        source4 - a fourth source MaybeSource
        +
        source5 - a fifth source MaybeSource
        +
        source6 - a sixth source MaybeSource
        +
        source7 - a seventh source MaybeSource
        +
        source8 - an eighth source MaybeSource
        +
        zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in + an item that will be emitted by the resulting Maybe
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6, + source7, source8 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> @NonNull Maybe<R> zip(@NonNull MaybeSource<? extends T1> source1,
+        @NonNull MaybeSource<? extends T2> source2,
+        @NonNull MaybeSource<? extends T3> source3,
+        @NonNull MaybeSource<? extends T4> source4,
+        @NonNull MaybeSource<? extends T5> source5,
+        @NonNull MaybeSource<? extends T6> source6,
+        @NonNull MaybeSource<? extends T7> source7,
+        @NonNull MaybeSource<? extends T8> source8,
+        @NonNull MaybeSource<? extends T9> source9,
+        @NonNull Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)
        +
        Returns a Maybe that emits the results of a specified combiner function applied to combinations of + nine items emitted, in sequence, by nine other MaybeSources. +

        + +

        + This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This + also means it is possible some sources may not get subscribed to at all. +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        T5 - the value type of the fifth source
        +
        T6 - the value type of the sixth source
        +
        T7 - the value type of the seventh source
        +
        T8 - the value type of the eighth source
        +
        T9 - the value type of the ninth source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source MaybeSource
        +
        source2 - a second source MaybeSource
        +
        source3 - a third source MaybeSource
        +
        source4 - a fourth source MaybeSource
        +
        source5 - a fifth source MaybeSource
        +
        source6 - a sixth source MaybeSource
        +
        source7 - a seventh source MaybeSource
        +
        source8 - an eighth source MaybeSource
        +
        source9 - a ninth source MaybeSource
        +
        zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in + an item that will be emitted by the resulting Maybe
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6, + source7, source8, source9 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zipArray

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+public static <T,R> @NonNull Maybe<R> zipArray(@NonNull Function<? super Object[],? extends R> zipper,
+        @NonNull MaybeSource<? extends T>... sources)
        +
        Returns a Maybe that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an array of other MaybeSources. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. + +

        + +

        This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This + also means it is possible some sources may not get subscribed to at all. +

        +
        Scheduler:
        +
        zipArray does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element type
        +
        R - the result type
        +
        Parameters:
        +
        sources - an array of source MaybeSources
        +
        zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in + an item that will be emitted by the resulting Maybe
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if sources or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + + + + + +
        +
      • +

        blockingGet

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @Nullable
+public final T blockingGet()
        +
        Waits in a blocking fashion until the current Maybe signals a success value (which is returned), + null if completed or an exception (which is propagated). +

        + +

        +
        Scheduler:
        +
        blockingGet does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the source signals an error, the operator wraps a checked Exception + into RuntimeException and throws that. Otherwise, RuntimeExceptions and + Errors are rethrown as they are.
        +
        +
        +
        Returns:
        +
        the success value
        +
        +
        • +
      + + + + + +
        +
      • +

        blockingGet

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final T blockingGet(@NonNull T defaultValue)
        +
        Waits in a blocking fashion until the current Maybe signals a success value (which is returned), + defaultValue if completed or an exception (which is propagated). +

        + +

        +
        Scheduler:
        +
        blockingGet does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the source signals an error, the operator wraps a checked Exception + into RuntimeException and throws that. Otherwise, RuntimeExceptions and + Errors are rethrown as they are.
        +
        +
        +
        Parameters:
        +
        defaultValue - the default item to return if this Maybe is empty
        +
        Returns:
        +
        the success value
        +
        Throws:
        +
        NullPointerException - if defaultValue is null
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        blockingSubscribe

        +
        @SchedulerSupport(value="none")
+public final void blockingSubscribe(@NonNull Consumer<? super T> onSuccess,
+        @NonNull Consumer<? super Throwable> onError,
+        @NonNull Action onComplete)
        +
        Subscribes to the current Maybe and calls the appropriate callback on the current thread + when it terminates. +

        + +

        +
        Scheduler:
        +
        blockingSubscribe does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If either onSuccess, onError or onComplete throw, the Throwable is routed to the + global error handler via RxJavaPlugins.onError(Throwable). + If the current thread is interrupted, the onError consumer is called with an InterruptedException. +
        +
        +
        +
        Parameters:
        +
        onSuccess - the Consumer to call if the current Maybe succeeds
        +
        onError - the Consumer to call if the current Maybe signals an error
        +
        onComplete - the Action to call if the current Maybe completes without a value
        +
        Throws:
        +
        NullPointerException - if onSuccess, onError or onComplete is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        blockingSubscribe

        +
        @SchedulerSupport(value="none")
+public final void blockingSubscribe(@NonNull MaybeObserver<? super T> observer)
        +
        Subscribes to the current Maybe and calls the appropriate MaybeObserver method on the current thread. +

        + +

        +
        Scheduler:
        +
        blockingSubscribe does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        An onError signal is delivered to the MaybeObserver.onError(Throwable) method. + If any of the MaybeObserver's methods throw, the RuntimeException is propagated to the caller of this method. + If the current thread is interrupted, an InterruptedException is delivered to observer.onError. +
        +
        +
        +
        Parameters:
        +
        observer - the MaybeObserver to call methods on the current thread
        +
        Throws:
        +
        NullPointerException - if observer is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        cache

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Maybe<T> cache()
        +
        Returns a Maybe that subscribes to this Maybe lazily, caches its event + and replays it, to all the downstream subscribers. +

        + +

        + The operator subscribes only when the first downstream subscriber subscribes and maintains + a single subscription towards this Maybe. +

        + Note: You sacrifice the ability to dispose the origin when you use the cache. +

        +
        Scheduler:
        +
        cache does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Maybe instance
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        dematerialize

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Maybe<R> dematerialize(@NonNull Function<? super T,Notification<R>> selector)
        +
        Maps the Notification success value of the current Maybe back into normal + onSuccess, onError or onComplete signals. +

        + +

        + The intended use of the selector function is to perform a + type-safe identity mapping (see example) on a source that is already of type + Notification<T>. The Java language doesn't allow + limiting instance methods to a certain generic argument shape, therefore, + a function is used to ensure the conversion remains type safe. +

        + Regular onError or onComplete signals from the current Maybe are passed along to the downstream. +

        +
        Scheduler:
        +
        dematerialize does not operate by default on a particular Scheduler.
        +
        +

        + Example: + 

        
+ Maybe.just(Notification.createOnNext(1))
+ .dematerialize(notification -> notification)
+ .test()
+ .assertResult(1);
+
        +
        +
        Type Parameters:
        +
        R - the result type
        +
        Parameters:
        +
        selector - the function called with the success item and should + return a Notification instance.
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if selector is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        materialize()
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        delay

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="custom")
+public final @NonNull Maybe<T> delay(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean delayError)
        +
        Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a + specified delay running on the specified Scheduler. +

        + +

        +
        Scheduler:
        +
        you specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        time - the delay to shift the source by
        +
        unit - the TimeUnit in which time is defined
        +
        scheduler - the Scheduler to use for delaying
        +
        delayError - if true, both success and error signals are delayed. if false, only success signals are delayed.
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        ReactiveX operators documentation: Delay
        +
        +
        • +
      + + + + + + + +
        +
      • +

        delaySubscription

        +
        @BackpressureSupport(value=UNBOUNDED_IN)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final <U> @NonNull Maybe<T> delaySubscription(@NonNull Publisher<U> subscriptionIndicator)
        +
        Returns a Maybe that delays the subscription to this Maybe + until the other Publisher emits an element or completes normally. +

        + +

        +
        Backpressure:
        +
        The Publisher source is consumed in an unbounded fashion (without applying backpressure).
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the value type of the other Publisher, irrelevant
        +
        Parameters:
        +
        subscriptionIndicator - the other Publisher that should trigger the subscription + to this Publisher.
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if subscriptionIndicator is null
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        doAfterSuccess

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Maybe<T> doAfterSuccess(@NonNull Consumer<? super T> onAfterSuccess)
        +
        Calls the specified Consumer with the success item after this item has been emitted to the downstream. +

        Note that the onAfterSuccess action is shared between subscriptions and as such + should be thread-safe. +

        + +

        +
        Scheduler:
        +
        doAfterSuccess does not operate by default on a particular Scheduler.
        +
        +

        History: 2.0.1 - experimental

        +
        +
        Parameters:
        +
        onAfterSuccess - the Consumer that will be called after emitting an item from upstream to the downstream
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if onAfterSuccess is null
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + + + + + +
        +
      • +

        doFinally

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Maybe<T> doFinally(@NonNull Action onFinally)
        +
        Calls the specified action after this Maybe signals onSuccess, onError or onComplete or gets disposed by + the downstream. +

        + +

        + In case of a race between a terminal event and a dispose call, the provided onFinally action + is executed once per subscription. +

        Note that the onFinally action is shared between subscriptions and as such + should be thread-safe. +

        +
        Scheduler:
        +
        doFinally does not operate by default on a particular Scheduler.
        +
        +

        History: 2.0.1 - experimental

        +
        +
        Parameters:
        +
        onFinally - the action called when this Maybe terminates or gets disposed
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if onFinally is null
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        doOnEvent

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Maybe<T> doOnEvent(@NonNull BiConsumer<? super T,? super Throwable> onEvent)
        +
        Calls the given onEvent callback with the (success value, null) for an onSuccess, (null, throwable) for + an onError or (null, null) for an onComplete signal from this Maybe before delivering said + signal to the downstream. +

        + +

        + The exceptions thrown from the callback will override the event so the downstream receives the + error instead of the original signal. +

        +
        Scheduler:
        +
        doOnEvent does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        onEvent - the callback to call with the success value or the exception, whichever is not null
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if onEvent is null
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final <U,R> @NonNull Maybe<R> flatMap(@NonNull Function<? super T,? extends MaybeSource<? extends U>> mapper,
+        @NonNull BiFunction<? super T,? super U,? extends R> combiner)
        +
        Returns a Maybe that emits the results of a specified function to the pair of values emitted by the + current Maybe and a specified mapped MaybeSource. +

        + +

        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the MaybeSource returned by the mapper function
        +
        R - the type of items emitted by the resulting Maybe
        +
        Parameters:
        +
        mapper - a function that returns a MaybeSource for the item emitted by the current Maybe
        +
        combiner - a function that combines one item emitted by each of the source and collection MaybeSource and + returns an item to be emitted by the resulting MaybeSource
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if mapper or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        flatMapSingle

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Maybe<R> flatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)
        +
        Returns a Maybe based on applying a specified function to the item emitted by the + current Maybe, where that function returns a Single. + When this Maybe just completes the resulting Maybe completes as well. +

        + +

        +
        Scheduler:
        +
        flatMapSingle does not operate by default on a particular Scheduler.
        +
        + +

        History: 2.0.2 - experimental

        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - a function that, when applied to the item emitted by the current Maybe, returns a + Single
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.1
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        lift

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Maybe<R> lift(@NonNull MaybeOperator<? extends R,? super T> lift)
        +
        This method requires advanced knowledge about building operators, please consider + other standard composition methods first; + Returns a Maybe which, when subscribed to, invokes the apply(MaybeObserver) method + of the provided MaybeOperator for each individual downstream Maybe and allows the + insertion of a custom operator by accessing the downstream's MaybeObserver during this subscription phase + and providing a new MaybeObserver, containing the custom operator's intended business logic, that will be + used in the subscription process going further upstream. +

        + +

        + Generally, such a new MaybeObserver will wrap the downstream's MaybeObserver and forwards the + onSuccess, onError and onComplete events from the upstream directly or according to the + emission pattern the custom operator's business logic requires. In addition, such operator can intercept the + flow control calls of dispose and isDisposed that would have traveled upstream and perform + additional actions depending on the same business logic requirements. +

        + Example: + 

        
+ // Step 1: Create the consumer type that will be returned by the MaybeOperator.apply():
+ 
+ public final class CustomMaybeObserver<T> implements MaybeObserver<T>, Disposable {
+
+     // The downstream's MaybeObserver that will receive the onXXX events
+     final MaybeObserver<? super String> downstream;
+
+     // The connection to the upstream source that will call this class' onXXX methods
+     Disposable upstream;
+
+     // The constructor takes the downstream subscriber and usually any other parameters
+     public CustomMaybeObserver(MaybeObserver<? super String> downstream) {
+         this.downstream = downstream;
+     }
+
+     // In the subscription phase, the upstream sends a Disposable to this class
+     // and subsequently this class has to send a Disposable to the downstream.
+     // Note that relaying the upstream's Disposable directly is not allowed in RxJava
+     @Override
+     public void onSubscribe(Disposable d) {
+         if (upstream != null) {
+             d.dispose();
+         } else {
+             upstream = d;
+             downstream.onSubscribe(this);
+         }
+     }
+
+     // The upstream calls this with the next item and the implementation's
+     // responsibility is to emit an item to the downstream based on the intended
+     // business logic, or if it can't do so for the particular item,
+        // request more from the upstream
+     @Override
+     public void onSuccess(T item) {
+         String str = item.toString();
+         if (str.length() < 2) {
+             downstream.onSuccess(str);
+         } else {
+             // Maybe is expected to produce one of the onXXX events only
+             downstream.onComplete();
+         }
+     }
+
+     // Some operators may handle the upstream's error while others
+     // could just forward it to the downstream.
+     @Override
+     public void onError(Throwable throwable) {
+         downstream.onError(throwable);
+     }
+
+     // When the upstream completes, usually the downstream should complete as well.
+     @Override
+     public void onComplete() {
+         downstream.onComplete();
+     }
+
+     // Some operators may use their own resources which should be cleaned up if
+     // the downstream disposes the flow before it completed. Operators without
+     // resources can simply forward the dispose to the upstream.
+     // In some cases, a disposed flag may be set by this method so that other parts
+     // of this class may detect the dispose and stop sending events
+     // to the downstream.
+     @Override
+     public void dispose() {
+         upstream.dispose();
+     }
+
+     // Some operators may simply forward the call to the upstream while others
+     // can return the disposed flag set in dispose().
+     @Override
+     public boolean isDisposed() {
+         return upstream.isDisposed();
+     }
+ }
+
+ // Step 2: Create a class that implements the MaybeOperator interface and
+ //         returns the custom consumer type from above in its apply() method.
+ //         Such class may define additional parameters to be submitted to
+ //         the custom consumer type.
+
+ final class CustomMaybeOperator<T> implements MaybeOperator<String> {
+     @Override
+     public MaybeObserver<? super String> apply(MaybeObserver<? super T> upstream) {
+         return new CustomMaybeObserver<T>(upstream);
+     }
+ }
+
+ // Step 3: Apply the custom operator via lift() in a flow by creating an instance of it
+ //         or reusing an existing one.
+
+ Maybe.just(5)
+ .lift(new CustomMaybeOperator<Integer>())
+ .test()
+ .assertResult("5");
+
+ Maybe.just(15)
+ .lift(new CustomMaybeOperator<Integer>())
+ .test()
+ .assertResult();
+
        +

        + Creating custom operators can be complicated and it is recommended one consults the + RxJava wiki: Writing operators page about + the tools, requirements, rules, considerations and pitfalls of implementing them. +

        + Note that implementing custom operators via this lift() method adds slightly more overhead by requiring + an additional allocation and indirection per assembled flows. Instead, extending the abstract Maybe + class and creating a MaybeTransformer with it is recommended. +

        + Note also that it is not possible to stop the subscription phase in lift() as the apply() method + requires a non-null MaybeObserver instance to be returned, which is then unconditionally subscribed to + the current Maybe. For example, if the operator decided there is no reason to subscribe to the + upstream source because of some optimization possibility or a failure to prepare the operator, it still has to + return a MaybeObserver that should immediately dispose the upstream's Disposable in its + onSubscribe method. Again, using a MaybeTransformer and extending the Maybe is + a better option as subscribeActual(io.reactivex.rxjava3.core.MaybeObserver<? super T>) can decide to not subscribe to its upstream after all. +

        +
        Scheduler:
        +
        lift does not operate by default on a particular Scheduler, however, the + MaybeOperator may use a Scheduler to support its own asynchronous behavior.
        +
        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        lift - the MaybeOperator that receives the downstream's MaybeObserver and should return + a MaybeObserver with custom behavior to be used as the consumer for the current + Maybe.
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if lift is null
        +
        See Also:
        +
        RxJava wiki: Writing operators, +compose(MaybeTransformer)
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        to

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+public final <R> R to(@NonNull MaybeConverter<T,? extends R> converter)
        +
        Calls the specified converter function during assembly time and returns its resulting value. +

        + +

        + This allows fluent conversion to any other type. +

        +
        Scheduler:
        +
        to does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.7 - experimental

        +
        +
        Type Parameters:
        +
        R - the resulting object type
        +
        Parameters:
        +
        converter - the function that receives the current Maybe instance and returns a value
        +
        Returns:
        +
        the converted value
        +
        Throws:
        +
        NullPointerException - if converter is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        onErrorComplete

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Maybe<T> onErrorComplete()
        +
        Returns a Maybe instance that if this Maybe emits an error, it will emit an onComplete + and swallow the throwable. +

        + +

        +
        Scheduler:
        +
        onErrorComplete does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Maybe instance
        +
        +
        • +
      + + + +
        +
      • +

        onErrorComplete

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Maybe<T> onErrorComplete(@NonNull Predicate<? super Throwable> predicate)
        +
        Returns a Maybe instance that if this Maybe emits an error and the predicate returns + true, it will emit an onComplete and swallow the throwable. +

        + +

        +
        Scheduler:
        +
        onErrorComplete does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        predicate - the predicate to call when an Throwable is emitted which should return true + if the Throwable should be swallowed and replaced with an onComplete.
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if predicate is null
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        onErrorReturn

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Maybe<T> onErrorReturn(@NonNull Function<? super Throwable,? extends T> itemSupplier)
        +
        Ends the flow with a success item returned by a function for the Throwable error signaled by the current + Maybe instead of signaling the error via onError. +

        + +

        + You can use this to prevent errors from propagating or to supply fallback data should errors be + encountered. +

        +
        Scheduler:
        +
        onErrorReturn does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        itemSupplier - a function that returns a single value that will be emitted as success value + the current Maybe signals an onError event
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if itemSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: Catch
        +
        +
        • +
      + + + + + +
        +
      • +

        onErrorReturnItem

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Maybe<T> onErrorReturnItem(@NonNull T item)
        +
        Ends the flow with the given success item when the current Maybe fails instead of signaling the error via onError. +

        + +

        + You can use this to prevent errors from propagating or to supply fallback data should errors be + encountered. +

        +
        Scheduler:
        +
        onErrorReturnItem does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        item - the value that is emitted as onSuccess in case the current Maybe signals an onError
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if item is null
        +
        See Also:
        +
        ReactiveX operators documentation: Catch
        +
        +
        • +
      + + + +
        +
      • +

        onTerminateDetach

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Maybe<T> onTerminateDetach()
        +
        Nulls out references to the upstream producer and downstream MaybeObserver if + the sequence is terminated or downstream calls dispose(). +

        + +

        +
        Scheduler:
        +
        onTerminateDetach does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Maybe instance + the sequence is terminated or downstream calls dispose()
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        repeatWhen

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> repeatWhen(@NonNull Function<? super Flowable<Object>,? extends Publisher<?>> handler)
        +
        Returns a Flowable that emits the same values as the current Maybe with the exception of an + onComplete. An onComplete notification from the source will result in the emission of + a void item to the Flowable provided as an argument to the notificationHandler + function. If that Publisher calls onComplete or onError then repeatWhen will + call onComplete or onError on the child observer. Otherwise, this operator will + resubscribe to the current Maybe. +

        + +

        +
        Backpressure:
        +
        The operator honors downstream backpressure and expects the source Publisher to honor backpressure as well. + If this expectation is violated, the operator may throw an IllegalStateException.
        +
        Scheduler:
        +
        repeatWhen does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        handler - receives a Publisher of notifications with which a user can complete or error, aborting the repeat.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if handler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Repeat
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        retryWhen

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Maybe<T> retryWhen(@NonNull Function<? super Flowable<Throwable>,? extends Publisher<?>> handler)
        +
        Returns a Maybe that emits the same values as the current Maybe with the exception of an + onError. An onError notification from the source will result in the emission of a + Throwable item to the Flowable provided as an argument to the notificationHandler + function. If the returned Publisher calls onComplete or onError then retry will call + onComplete or onError on the child subscription. Otherwise, this operator will + resubscribe to the current Maybe. +

        + +

        + Example: + + This retries 3 times, each time incrementing the number of seconds it waits. + + 

        
+  Maybe.create((MaybeEmitter<? super String> s) -> {
+      System.out.println("subscribing");
+      s.onError(new RuntimeException("always fails"));
+  }, BackpressureStrategy.BUFFER).retryWhen(attempts -> {
+      return attempts.zipWith(Publisher.range(1, 3), (n, i) -> i).flatMap(i -> {
+          System.out.println("delay retry by " + i + " second(s)");
+          return Flowable.timer(i, TimeUnit.SECONDS);
+      });
+  }).blockingForEach(System.out::println);
+
        + + Output is: + + 
         
+ subscribing
+ delay retry by 1 second(s)
+ subscribing
+ delay retry by 2 second(s)
+ subscribing
+ delay retry by 3 second(s)
+ subscribing
+
        +

        + Note that the inner Publisher returned by the handler function should signal + either onNext, onError or onComplete in response to the received + Throwable to indicate the operator should retry or terminate. If the upstream to + the operator is asynchronous, signalling onNext followed by onComplete immediately may + result in the sequence to be completed immediately. Similarly, if this inner + Publisher signals onError or onComplete while the upstream is + active, the sequence is terminated with the same signal immediately. +

        + The following example demonstrates how to retry an asynchronous source with a delay: + 

        
+ Maybe.timer(1, TimeUnit.SECONDS)
+     .doOnSubscribe(s -> System.out.println("subscribing"))
+     .map(v -> { throw new RuntimeException(); })
+     .retryWhen(errors -> {
+         AtomicInteger counter = new AtomicInteger();
+         return errors
+                   .takeWhile(e -> counter.getAndIncrement() != 3)
+                   .flatMap(e -> {
+                       System.out.println("delay retry by " + counter.get() + " second(s)");
+                       return Flowable.timer(counter.get(), TimeUnit.SECONDS);
+                   });
+     })
+     .blockingGet();
+
        +
        +
        Scheduler:
        +
        retryWhen does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        handler - receives a Publisher of notifications with which a user can complete or error, aborting the + retry
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if handler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Retry
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        subscribe

        +
        @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Disposable subscribe(@NonNull Consumer<? super T> onSuccess,
+        @NonNull Consumer<? super Throwable> onError,
+        @NonNull Action onComplete,
+        @NonNull DisposableContainer container)
        +
        Wraps the given onXXX callbacks into a Disposable MaybeObserver, + adds it to the given DisposableContainer and ensures, that if the upstream + terminates or this particular Disposable is disposed, the MaybeObserver is removed + from the given composite. +

        + The MaybeObserver will be removed after the callback for the terminal event has been invoked. +

        +
        Scheduler:
        +
        subscribe does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        onSuccess - the callback for upstream items
        +
        onError - the callback for an upstream error
        +
        onComplete - the callback for an upstream completion without any value or error
        +
        container - the DisposableContainer (such as CompositeDisposable) to add and remove the + created Disposable MaybeObserver
        +
        Returns:
        +
        the Disposable that allows disposing the particular subscription.
        +
        Throws:
        +
        NullPointerException - if onSuccess, onError, + onComplete or container is null
        +
        Since:
        +
        3.1.0
        +
        +
        • +
      + + + + + + + +
        +
      • +

        subscribeActual

        +
        protected abstract void subscribeActual(@NonNull MaybeObserver<? super T> observer)
        +
        Implement this method in subclasses to handle the incoming MaybeObservers. +

        There is no need to call any of the plugin hooks on the current Maybe instance or + the MaybeObserver; all hooks and basic safeguards have been + applied by subscribe(MaybeObserver) before this method gets called.

        +
        +
        Parameters:
        +
        observer - the MaybeObserver to handle, not null
        +
        +
        • +
      + + + + + + + + + +
        +
      • +

        subscribeWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <E extends MaybeObserver<? super T>> E subscribeWith(E observer)
        +
        Subscribes a given MaybeObserver (subclass) to this Maybe and returns the given + MaybeObserver as is. +

        Usage example: + 

        
+ Maybe<Integer> source = Maybe.just(1);
+ CompositeDisposable composite = new CompositeDisposable();
+
+ DisposableMaybeObserver<Integer> ds = new DisposableMaybeObserver<>() {
+     // ...
+ };
+
+ composite.add(source.subscribeWith(ds));
+
        +
        +
        Scheduler:
        +
        subscribeWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        E - the type of the MaybeObserver to use and return
        +
        Parameters:
        +
        observer - the MaybeObserver (subclass) to use and return, not null
        +
        Returns:
        +
        the input observer
        +
        Throws:
        +
        NullPointerException - if observer is null
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        timeInterval

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="io.reactivex:computation")
+public final @NonNull Maybe<Timed<T>> timeInterval()
        +
        Measures the time (in milliseconds) between the subscription and success item emission + of the current Maybe and signals it as a tuple (Timed) + success value. +

        + +

        + If the current Maybe is empty or fails, the resulting Maybe will + pass along the signals to the downstream. To measure the time to termination, + use materialize() and apply Single.timeInterval(). +

        +
        Scheduler:
        +
        timeInterval uses the computation Scheduler + for determining the current time upon subscription and upon receiving the + success item from the current Maybe.
        +
        +
        +
        Returns:
        +
        the new Maybe instance
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        timeInterval

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="custom")
+public final @NonNull Maybe<Timed<T>> timeInterval(@NonNull Scheduler scheduler)
        +
        Measures the time (in milliseconds) between the subscription and success item emission + of the current Maybe and signals it as a tuple (Timed) + success value. +

        + +

        + If the current Maybe is empty or fails, the resulting Maybe will + pass along the signals to the downstream. To measure the time to termination, + use materialize() and apply Single.timeInterval(Scheduler). +

        +
        Scheduler:
        +
        timeInterval uses the provided Scheduler + for determining the current time upon subscription and upon receiving the + success item from the current Maybe.
        +
        +
        +
        Parameters:
        +
        scheduler - the Scheduler used for providing the current time
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if scheduler is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        timeInterval

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="io.reactivex:computation")
+public final @NonNull Maybe<Timed<T>> timeInterval(@NonNull TimeUnit unit)
        +
        Measures the time between the subscription and success item emission + of the current Maybe and signals it as a tuple (Timed) + success value. +

        + +

        + If the current Maybe is empty or fails, the resulting Maybe will + pass along the signals to the downstream. To measure the time to termination, + use materialize() and apply Single.timeInterval(TimeUnit). +

        +
        Scheduler:
        +
        timeInterval uses the computation Scheduler + for determining the current time upon subscription and upon receiving the + success item from the current Maybe.
        +
        +
        +
        Parameters:
        +
        unit - the time unit for measurement
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        timeInterval

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="custom")
+public final @NonNull Maybe<Timed<T>> timeInterval(@NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Measures the time between the subscription and success item emission + of the current Maybe and signals it as a tuple (Timed) + success value. +

        + +

        + If the current Maybe is empty or fails, the resulting Maybe will + pass along the signals to the downstream. To measure the time to termination, + use materialize() and apply Single.timeInterval(TimeUnit, Scheduler). +

        +
        Scheduler:
        +
        timeInterval uses the provided Scheduler + for determining the current time upon subscription and upon receiving the + success item from the current Maybe.
        +
        +
        +
        Parameters:
        +
        unit - the time unit for measurement
        +
        scheduler - the Scheduler used for providing the current time
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        timestamp

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="io.reactivex:computation")
+public final @NonNull Maybe<Timed<T>> timestamp()
        +
        Combines the success value from the current Maybe with the current time (in milliseconds) of + its reception, using the computation Scheduler as time source, + then signals them as a Timed instance. +

        + +

        + If the current Maybe is empty or fails, the resulting Maybe will + pass along the signals to the downstream. To measure the time to termination, + use materialize() and apply Single.timestamp(). +

        +
        Scheduler:
        +
        timestamp uses the computation Scheduler + for determining the current time upon receiving the + success item from the current Maybe.
        +
        +
        +
        Returns:
        +
        the new Maybe instance
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        timestamp

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="custom")
+public final @NonNull Maybe<Timed<T>> timestamp(@NonNull Scheduler scheduler)
        +
        Combines the success value from the current Maybe with the current time (in milliseconds) of + its reception, using the given Scheduler as time source, + then signals them as a Timed instance. +

        + +

        + If the current Maybe is empty or fails, the resulting Maybe will + pass along the signals to the downstream. To measure the time to termination, + use materialize() and apply Single.timestamp(Scheduler). +

        +
        Scheduler:
        +
        timestamp uses the provided Scheduler + for determining the current time upon receiving the + success item from the current Maybe.
        +
        +
        +
        Parameters:
        +
        scheduler - the Scheduler used for providing the current time
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if scheduler is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        timestamp

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="io.reactivex:computation")
+public final @NonNull Maybe<Timed<T>> timestamp(@NonNull TimeUnit unit)
        +
        Combines the success value from the current Maybe with the current time of + its reception, using the computation Scheduler as time source, + then signals it as a Timed instance. +

        + +

        + If the current Maybe is empty or fails, the resulting Maybe will + pass along the signals to the downstream. To measure the time to termination, + use materialize() and apply Single.timestamp(TimeUnit). +

        +
        Scheduler:
        +
        timestamp uses the computation Scheduler, + for determining the current time upon receiving the + success item from the current Maybe.
        +
        +
        +
        Parameters:
        +
        unit - the time unit for measurement
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        timestamp

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="custom")
+public final @NonNull Maybe<Timed<T>> timestamp(@NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Combines the success value from the current Maybe with the current time of + its reception, using the given Scheduler as time source, + then signals it as a Timed instance. +

        + +

        + If the current Maybe is empty or fails, the resulting Maybe will + pass along the signals to the downstream. To measure the time to termination, + use materialize() and apply Single.timestamp(TimeUnit, Scheduler). +

        +
        Scheduler:
        +
        timestamp uses the provided Scheduler, + which is used for determining the current time upon receiving the + success item from the current Maybe.
        +
        +
        +
        Parameters:
        +
        unit - the time unit for measurement
        +
        scheduler - the Scheduler used for providing the current time
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + + + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="io.reactivex:computation")
+public final @NonNull Maybe<T> timeout(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull MaybeSource<? extends T> fallback)
        +
        Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted + item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, + the current Maybe is disposed and resulting Maybe begins instead to mirror a fallback MaybeSource. +

        + +

        +
        Scheduler:
        +
        This version of timeout operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timeout - maximum duration between items before a timeout occurs
        +
        unit - the unit of time that applies to the timeout argument
        +
        fallback - the fallback MaybeSource to use in case of a timeout
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if unit or fallback is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="custom")
+public final @NonNull Maybe<T> timeout(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        @NonNull MaybeSource<? extends T> fallback)
        +
        Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted + item using a specified Scheduler. If the next item isn't emitted within the specified timeout duration + starting from its predecessor, the current Maybe is disposed and resulting Maybe begins instead + to mirror a fallback MaybeSource. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timeout - maximum duration between items before a timeout occurs
        +
        unit - the unit of time that applies to the timeout argument
        +
        fallback - the MaybeSource to use as the fallback in case of a timeout
        +
        scheduler - the Scheduler to run the timeout timers on
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if fallback, unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final <U> @NonNull Maybe<T> timeout(@NonNull MaybeSource<U> timeoutIndicator,
+        @NonNull MaybeSource<? extends T> fallback)
        +
        If the current Maybe didn't signal an event before the timeoutIndicator MaybeSource signals, + the current Maybe is disposed and the fallback MaybeSource subscribed to + as a continuation. +

        + +

        +
        Scheduler:
        +
        timeout does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the value type of the
        +
        Parameters:
        +
        timeoutIndicator - the MaybeSource that indicates the timeout by signaling onSuccess + or onComplete.
        +
        fallback - the MaybeSource that is subscribed to if the current Maybe times out
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if timeoutIndicator or fallback is null
        +
        +
        • +
      + + + + + + + +
        +
      • +

        timeout

        +
        @BackpressureSupport(value=UNBOUNDED_IN)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final <U> @NonNull Maybe<T> timeout(@NonNull Publisher<U> timeoutIndicator,
+        @NonNull MaybeSource<? extends T> fallback)
        +
        If the current Maybe didn't signal an event before the timeoutIndicator Publisher signals, + the current Maybe is disposed and the fallback MaybeSource subscribed to + as a continuation. +

        + +

        +
        Backpressure:
        +
        The timeoutIndicator Publisher is consumed in an unbounded manner and + is cancelled after its first item.
        +
        Scheduler:
        +
        timeout does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the value type of the
        +
        Parameters:
        +
        timeoutIndicator - the MaybeSource that indicates the timeout by signaling onSuccess + or onComplete
        +
        fallback - the MaybeSource that is subscribed to if the current Maybe times out
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if timeoutIndicator or fallback is null
        +
        +
        • +
      + + + + + + + +
        +
      • +

        zipWith

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final <U,R> @NonNull Maybe<R> zipWith(@NonNull MaybeSource<? extends U> other,
+        @NonNull BiFunction<? super T,? super U,? extends R> zipper)
        +
        Waits until this and the other MaybeSource signal a success value then applies the given BiFunction + to those values and emits the BiFunction's resulting value to downstream. + + + +

        If either this or the other MaybeSource is empty or signals an error, the resulting Maybe will + terminate immediately and dispose the other source. + +

        +
        Scheduler:
        +
        zipWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the other MaybeSource
        +
        R - the type of items emitted by the resulting Maybe
        +
        Parameters:
        +
        other - the other MaybeSource
        +
        zipper - a function that combines the pairs of items from the two MaybeSources to generate the items to + be emitted by the resulting Maybe
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if other or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + + + + + +
        +
      • +

        test

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull TestObserver<T> test(boolean dispose)
        +
        Creates a TestObserver optionally in cancelled state, then subscribes it to this Maybe. +
        +
        Scheduler:
        +
        test does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        dispose - if true, the TestObserver will be disposed before subscribing to this + Maybe.
        +
        Returns:
        +
        the new TestObserver instance
        +
        +
        • +
      + + + +
        +
      • +

        fromOptional

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Maybe<T> fromOptional(@NonNull Optional<T> optional)
        +
        Converts the existing value of the provided optional into a just(Object) + or an empty optional into an empty() Maybe instance. +

        + +

        + Note that the operator takes an already instantiated optional reference and does not + by any means create this original optional. If the optional is to be created per + consumer upon subscription, use defer(Supplier) around fromOptional: + 

        
+ Maybe.defer(() -> Maybe.fromOptional(createOptional()));
+
        +
        +
        Scheduler:
        +
        fromOptional does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the optional value
        +
        Parameters:
        +
        optional - the optional value to convert into a Maybe
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if optional is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        just(Object), +empty()
        +
        +
        • +
      + + + +
        +
      • +

        fromCompletionStage

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Maybe<T> fromCompletionStage(@NonNull CompletionStage<T> stage)
        +
        Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation. +

        + +

        + Note that the operator takes an already instantiated, running or terminated CompletionStage. + If the CompletionStage is to be created per consumer upon subscription, use defer(Supplier) + around fromCompletionStage: + 

        
+ Maybe.defer(() -> Maybe.fromCompletionStage(createCompletionStage()));
+
        +

        + If the CompletionStage completes with null, the resulting Maybe is completed via onComplete. +

        + Canceling the flow can't cancel the execution of the CompletionStage because CompletionStage + itself doesn't support cancellation. Instead, the operator detaches from the CompletionStage. +

        +
        Scheduler:
        +
        fromCompletionStage does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the CompletionStage
        +
        Parameters:
        +
        stage - the CompletionStage to convert to Maybe and signal its terminal value or error
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if stage is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        mapOptional

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Maybe<R> mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper)
        +
        Maps the upstream success value into an Optional and emits the contained item if not empty. +

        + + +

        +
        Scheduler:
        +
        mapOptional does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the non-null output type
        +
        Parameters:
        +
        mapper - the function that receives the upstream success item and should return a non-empty Optional + to emit as the success output or an empty Optional to complete the Maybe
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        map(Function), +filter(Predicate)
        +
        +
        • +
      + + + + + + + + + + + + + +
        +
      • +

        flattenStreamAsFlowable

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=FULL)
+ @NonNull
+public final <R> @NonNull Flowable<R> flattenStreamAsFlowable(@NonNull Function<? super T,? extends Stream<? extends R>> mapper)
        +
        Maps the upstream succecss value into a Java Stream and emits its + items to the downstream consumer as a Flowable. +

        + +

        + The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when + closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). + If a Stream should not be closed, turn it into an Iterable and use flattenAsFlowable(Function): + 

        
+ source.flattenAsFlowable(item -> createStream(item)::iterator);
+
        +

        + Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): + 

        
+ source.flattenStreamAsFlowable(item -> IntStream.rangeClosed(1, 10).boxed());
+
        +

        + Stream does not support concurrent usage so creating and/or consuming the same instance multiple times + from multiple threads can lead to undefined behavior. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and iterates the given Stream + on demand (i.e., when requested).
        +
        Scheduler:
        +
        flattenStreamAsFlowable does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the Stream and the output Flowable
        +
        Parameters:
        +
        mapper - the function that receives the upstream success item and should + return a Stream of values to emit.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        flattenAsFlowable(Function), +flattenStreamAsObservable(Function)
        +
        +
        • +
      + + + +
        +
      • +

        flattenStreamAsObservable

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> flattenStreamAsObservable(@NonNull Function<? super T,? extends Stream<? extends R>> mapper)
        +
        Maps the upstream succecss value into a Java Stream and emits its + items to the downstream consumer as an Observable. + +

        + The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when + closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). + If a Stream should not be closed, turn it into an Iterable and use flattenAsObservable(Function): + 

        
+ source.flattenAsObservable(item -> createStream(item)::iterator);
+
        +

        + Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): + 

        
+ source.flattenStreamAsObservable(item -> IntStream.rangeClosed(1, 10).boxed());
+
        +

        + Stream does not support concurrent usage so creating and/or consuming the same instance multiple times + from multiple threads can lead to undefined behavior. +

        +
        Scheduler:
        +
        flattenStreamAsObservable does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the Stream and the output Observable
        +
        Parameters:
        +
        mapper - the function that receives the upstream success item and should + return a Stream of values to emit.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        flattenAsObservable(Function), +flattenStreamAsFlowable(Function)
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeConverter.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeConverter.html new file mode 100644 index 0000000000..a50f20cf6e --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeConverter.html @@ -0,0 +1,246 @@ + + + + + +MaybeConverter (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface MaybeConverter<T,R>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the upstream type
    +
    R - the output type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface MaybeConverter<T,R>
    +
    Convenience interface and callback used by the Maybe.to(io.reactivex.rxjava3.core.MaybeConverter<T, ? extends R>) operator to turn a Maybe into another + value fluently. +

    History: 2.1.7 - experimental

    +
    +
    Since:
    +
    2.2
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        apply

        +
        @NonNull
+R apply(@NonNull
+                 @NonNull Maybe<T> upstream)
        +
        Applies a function to the upstream Maybe and returns a converted value of type R.
        +
        +
        Parameters:
        +
        upstream - the upstream Maybe instance
        +
        Returns:
        +
        the converted value
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeEmitter.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeEmitter.html new file mode 100644 index 0000000000..099e00201b --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeEmitter.html @@ -0,0 +1,404 @@ + + + + + +MaybeEmitter (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface MaybeEmitter<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type to emit
    +
    +
    +
    +
    public interface MaybeEmitter<T>
    +
    Abstraction over an RxJava MaybeObserver that allows associating + a resource with it. +

    + All methods are safe to call from multiple threads, but note that there is no guarantee + whose terminal event will win and get delivered to the downstream. +

    + Calling onSuccess(Object) or onComplete() multiple times has no effect. + Calling onError(Throwable) multiple times or after the other two will route the + exception into the global error handler via RxJavaPlugins.onError(Throwable). +

    + The emitter allows the registration of a single resource, in the form of a Disposable + or Cancellable via setDisposable(Disposable) or setCancellable(Cancellable) + respectively. The emitter implementations will dispose/cancel this instance when the + downstream cancels the flow or after the event generator logic calls onSuccess(Object), + onError(Throwable), onComplete() or when tryOnError(Throwable) succeeds. +

    + Only one Disposable or Cancellable object can be associated with the emitter at + a time. Calling either set method will dispose/cancel any previous object. If there + is a need for handling multiple resources, one can create a CompositeDisposable + and associate that with the emitter instead. +

    + The Cancellable is logically equivalent to Disposable but allows using cleanup logic that can + throw a checked exception (such as many close() methods on Java IO components). Since + the release of resources happens after the terminal events have been delivered or the sequence gets + cancelled, exceptions throw within Cancellable are routed to the global error handler via + RxJavaPlugins.onError(Throwable).

    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        onSuccess

        +
        void onSuccess(@NonNull
+               T t)
        +
        Signal a success value.
        +
        +
        Parameters:
        +
        t - the value, not null
        +
        +
        • +
      + + + +
        +
      • +

        onError

        +
        void onError(@NonNull
+             @NonNull Throwable t)
        +
        Signal an exception.
        +
        +
        Parameters:
        +
        t - the exception, not null
        +
        +
        • +
      + + + +
        +
      • +

        onComplete

        +
        void onComplete()
        +
        Signal the completion.
        +
        • +
      + + + +
        +
      • +

        setDisposable

        +
        void setDisposable(@Nullable
+                   @Nullable Disposable d)
        +
        Sets a Disposable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled. +

        This method is thread-safe.

        +
        +
        Parameters:
        +
        d - the disposable, null is allowed
        +
        +
        • +
      + + + +
        +
      • +

        setCancellable

        +
        void setCancellable(@Nullable
+                    @Nullable Cancellable c)
        +
        Sets a Cancellable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled. +

        This method is thread-safe.

        +
        +
        Parameters:
        +
        c - the Cancellable resource, null is allowed
        +
        +
        • +
      + + + +
        +
      • +

        isDisposed

        +
        boolean isDisposed()
        +
        Returns true if the downstream disposed the sequence or the + emitter was terminated via onSuccess(Object), onError(Throwable), + onComplete() or a + successful tryOnError(Throwable). +

        This method is thread-safe.

        +
        +
        Returns:
        +
        true if the downstream disposed the sequence or the emitter was terminated
        +
        +
        • +
      + + + +
        +
      • +

        tryOnError

        +
        boolean tryOnError(@NonNull
+                   @NonNull Throwable t)
        +
        Attempts to emit the specified Throwable error if the downstream + hasn't cancelled the sequence or is otherwise terminated, returning false + if the emission is not allowed to happen due to lifecycle restrictions. +

        + Unlike onError(Throwable), the RxjavaPlugins.onError + is not called if the error could not be delivered. +

        History: 2.1.1 - experimental

        +
        +
        Parameters:
        +
        t - the Throwable error to signal if possible
        +
        Returns:
        +
        true if successful, false if the downstream is not able to accept further + events
        +
        Since:
        +
        2.2
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeObserver.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeObserver.html new file mode 100644 index 0000000000..88ed8c3e3b --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeObserver.html @@ -0,0 +1,342 @@ + + + + + +MaybeObserver (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface MaybeObserver<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the type of item the MaybeObserver expects to observe
    +
    +
    +
    All Known Implementing Classes:
    +
    DisposableMaybeObserver, MaybeSubject, ResourceMaybeObserver, TestObserver
    +
    +
    +
    +
    public interface MaybeObserver<T>
    +
    Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value. +

    + When a MaybeObserver is subscribed to a MaybeSource through the MaybeSource.subscribe(MaybeObserver) method, + the MaybeSource calls onSubscribe(Disposable) with a Disposable that allows + disposing the sequence at any time. A well-behaved + MaybeSource will call a MaybeObserver's onSuccess(Object), onError(Throwable) + or onComplete() method exactly once as they are considered mutually exclusive terminal signals. +

    + Calling the MaybeObserver's method must happen in a serialized fashion, that is, they must not + be invoked concurrently by multiple threads in an overlapping fashion and the invocation pattern must + adhere to the following protocol: + 

        onSubscribe (onSuccess | onError | onComplete)?
    +

    + Note that unlike with the Observable protocol, onComplete() is not called after the success item has been + signalled via onSuccess(Object). +

    + Subscribing a MaybeObserver to multiple MaybeSources is not recommended. If such reuse + happens, it is the duty of the MaybeObserver implementation to be ready to receive multiple calls to + its methods and ensure proper concurrent behavior of its business logic. +

    + Calling onSubscribe(Disposable), onSuccess(Object) or onError(Throwable) with a + null argument is forbidden. +

    + The implementations of the onXXX methods should avoid throwing runtime exceptions other than the following cases: +

      +
    • If the argument is null, the methods can throw a NullPointerException. + Note though that RxJava prevents nulls to enter into the flow and thus there is generally no + need to check for nulls in flows assembled from standard sources and intermediate operators. +
      • +
    • If there is a fatal error (such as VirtualMachineError).
      • +
    +
    +
    Since:
    +
    2.0
    +
    See Also:
    +
    ReactiveX documentation: Observable
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        onSubscribe

        +
        void onSubscribe(@NonNull
+                 @NonNull Disposable d)
        +
        Provides the MaybeObserver with the means of cancelling (disposing) the + connection (channel) with the Maybe in both + synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.
        +
        +
        Parameters:
        +
        d - the Disposable instance whose Disposable.dispose() can + be called anytime to cancel the connection
        +
        +
        • +
      + + + + + + + + + + + + + +
        +
      • +

        onComplete

        +
        void onComplete()
        +
        Called once the deferred computation completes normally.
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeOnSubscribe.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeOnSubscribe.html new file mode 100644 index 0000000000..8dc94f155f --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeOnSubscribe.html @@ -0,0 +1,241 @@ + + + + + +MaybeOnSubscribe (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface MaybeOnSubscribe<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type pushed
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface MaybeOnSubscribe<T>
    +
    A functional interface that has a subscribe() method that receives + a MaybeEmitter instance that allows pushing + an event in a cancellation-safe manner.
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeOperator.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeOperator.html new file mode 100644 index 0000000000..4d8274d1f3 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeOperator.html @@ -0,0 +1,243 @@ + + + + + +MaybeOperator (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface MaybeOperator<Downstream,Upstream>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    Downstream - the value type of the downstream
    +
    Upstream - the value type of the upstream
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface MaybeOperator<Downstream,Upstream>
    +
    Interface to map/wrap a downstream MaybeObserver to an upstream MaybeObserver.
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeSource.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeSource.html new file mode 100644 index 0000000000..81c990b7f5 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeSource.html @@ -0,0 +1,250 @@ + + + + + +MaybeSource (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface MaybeSource<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the element type
    +
    +
    +
    All Known Implementing Classes:
    +
    Maybe, MaybeSubject
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface MaybeSource<T>
    +
    Represents a basic Maybe source base interface, + consumable via an MaybeObserver. +

    + This class also serves the base type for custom operators wrapped into + Maybe via Maybe.create(MaybeOnSubscribe).

    +
    +
    Since:
    +
    2.0
    +
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeTransformer.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeTransformer.html new file mode 100644 index 0000000000..8427ca3c4a --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/MaybeTransformer.html @@ -0,0 +1,242 @@ + + + + + +MaybeTransformer (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface MaybeTransformer<Upstream,Downstream>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    Upstream - the upstream value type
    +
    Downstream - the downstream value type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface MaybeTransformer<Upstream,Downstream>
    +
    Interface to compose Maybes.
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Notification.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Notification.html new file mode 100644 index 0000000000..028f1d304d --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Notification.html @@ -0,0 +1,478 @@ + + + + + +Notification (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Class Notification<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    +
    public final class Notification<T>
+extends Object
    +
    Represents the reactive signal types: onNext, onError and onComplete and + holds their parameter values (a value, a Throwable, nothing).
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        isOnComplete

        +
        public boolean isOnComplete()
        +
        Returns true if this notification is an onComplete signal.
        +
        +
        Returns:
        +
        true if this notification is an onComplete signal
        +
        +
        • +
      + + + +
        +
      • +

        isOnError

        +
        public boolean isOnError()
        +
        Returns true if this notification is an onError signal and + getError() returns the contained Throwable.
        +
        +
        Returns:
        +
        true if this notification is an onError signal
        +
        See Also:
        +
        getError()
        +
        +
        • +
      + + + +
        +
      • +

        isOnNext

        +
        public boolean isOnNext()
        +
        Returns true if this notification is an onNext signal and + getValue() returns the contained value.
        +
        +
        Returns:
        +
        true if this notification is an onNext signal
        +
        See Also:
        +
        getValue()
        +
        +
        • +
      + + + +
        +
      • +

        getValue

        +
        @Nullable
+public T getValue()
        +
        Returns the contained value if this notification is an onNext + signal, null otherwise.
        +
        +
        Returns:
        +
        the value contained or null
        +
        See Also:
        +
        isOnNext()
        +
        +
        • +
      + + + +
        +
      • +

        getError

        +
        @Nullable
+public @Nullable Throwable getError()
        +
        Returns the container Throwable error if this notification is an onError + signal, null otherwise.
        +
        +
        Returns:
        +
        the Throwable error contained or null
        +
        See Also:
        +
        isOnError()
        +
        +
        • +
      + + + +
        +
      • +

        equals

        +
        public boolean equals(Object obj)
        +
        +
        Overrides:
        +
        equals in class Object
        +
        +
        • +
      + + + +
        +
      • +

        hashCode

        +
        public int hashCode()
        +
        +
        Overrides:
        +
        hashCode in class Object
        +
        +
        • +
      + + + + + + + + + +
        +
      • +

        createOnNext

        +
        @NonNull
+public static <T> @NonNull Notification<T> createOnNext(T value)
        +
        Constructs an onNext notification containing the given value.
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        value - the value to carry around in the notification, not null
        +
        Returns:
        +
        the new Notification instance
        +
        Throws:
        +
        NullPointerException - if value is null
        +
        +
        • +
      + + + +
        +
      • +

        createOnError

        +
        @NonNull
+public static <T> @NonNull Notification<T> createOnError(@NonNull
+                                                                  @NonNull Throwable error)
        +
        Constructs an onError notification containing the error.
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        error - the error Throwable to carry around in the notification, not null
        +
        Returns:
        +
        the new Notification instance
        +
        Throws:
        +
        NullPointerException - if error is null
        +
        +
        • +
      + + + +
        +
      • +

        createOnComplete

        +
        @NonNull
+public static <T> @NonNull Notification<T> createOnComplete()
        +
        Returns the empty and stateless shared instance of a notification representing + an onComplete signal.
        +
        +
        Type Parameters:
        +
        T - the target value type
        +
        Returns:
        +
        the shared Notification instance representing an onComplete signal
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Observable.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Observable.html new file mode 100644 index 0000000000..5a64c7b9e6 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Observable.html @@ -0,0 +1,24457 @@ + + + + + +Observable (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Class Observable<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the type of the items emitted by the Observable
    +
    +
    +
    All Implemented Interfaces:
    +
    ObservableSource<T>
    +
    +
    +
    Direct Known Subclasses:
    +
    ConnectableObservable, GroupedObservable, Subject
    +
    +
    +
    +
    public abstract class Observable<T>
+extends Object
+implements ObservableSource<T>
    +
    The Observable class is the non-backpressured, optionally multi-valued base reactive class that + offers factory methods, intermediate operators and the ability to consume synchronous + and/or asynchronous reactive dataflows. +

    + Many operators in the class accept ObservableSource(s), the base reactive interface + for such non-backpressured flows, which Observable itself implements as well. +

    + The Observable's operators, by default, run with a buffer size of 128 elements (see Flowable.bufferSize()), + that can be overridden globally via the system parameter rx3.buffer-size. Most operators, however, have + overloads that allow setting their internal buffer size explicitly. +

    + The documentation for this class makes use of marble diagrams. The following legend explains these diagrams: +

    + +

    + The design of this class was derived from the + Reactive-Streams design and specification + by removing any backpressure-related infrastructure and implementation detail, replacing the + org.reactivestreams.Subscription with Disposable as the primary means to dispose of + a flow. +

    + The Observable follows the protocol + 

    
+      onSubscribe onNext* (onError | onComplete)?
+
    + where + the stream can be disposed through the Disposable instance provided to consumers through + Observer.onSubscribe. +

    + Unlike the Observable of version 1.x, subscribe(Observer) does not allow external disposal + of a subscription and the Observer instance is expected to expose such capability. +

    Example: + 

    
+ Disposable d = Observable.just("Hello world!")
+     .delay(1, TimeUnit.SECONDS)
+     .subscribeWith(new DisposableObserver<String>() {
+         @Override public void onStart() {
+             System.out.println("Start!");
+         }
+         @Override public void onNext(String t) {
+             System.out.println(t);
+         }
+         @Override public void onError(Throwable t) {
+             t.printStackTrace();
+         }
+         @Override public void onComplete() {
+             System.out.println("Done!");
+         }
+     });
+
+ Thread.sleep(500);
+ // the sequence can now be disposed via dispose()
+ d.dispose();
+
    +
    +
    See Also:
    +
    Flowable, +DisposableObserver
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Observable

        +
        public Observable()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        ambArray

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+public static <T> @NonNull Observable<T> ambArray(@NonNull ObservableSource<? extends T>... sources)
        +
        Mirrors the one ObservableSource in an array of several ObservableSources that first either emits an item or sends + a termination notification. +

        + +

        + When one of the ObservableSources signal an item or terminates first, all subscriptions to the other + ObservableSources are disposed. +

        +
        Scheduler:
        +
        ambArray does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        + If any of the losing ObservableSources signals an error, the error is routed to the global + error handler via RxJavaPlugins.onError(Throwable). +
        +
        +
        +
        Type Parameters:
        +
        T - the common element type
        +
        Parameters:
        +
        sources - an array of ObservableSource sources competing to react first. A subscription to each source will + occur in the same order as in the array.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Amb
        +
        +
        • +
      + + + +
        +
      • +

        bufferSize

        +
        @CheckReturnValue
+public static int bufferSize()
        +
        Returns the default 'island' size or capacity-increment hint for unbounded buffers. +

        Delegates to Flowable.bufferSize() but is public for convenience. +

        The value can be overridden via system parameter rx3.buffer-size + before the Flowable class is loaded.

        +
        +
        Returns:
        +
        the default 'island' size or capacity-increment hint
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T,R> @NonNull Observable<R> combineLatest(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
+        @NonNull Function<? super Object[],? extends R> combiner)
        +
        Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of + the returned ObservableSources each time an item is received from any of the returned ObservableSources, where this + aggregation is defined by a specified function. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided iterable of ObservableSources is empty, the resulting sequence completes immediately without emitting + any items and without any calls to the combiner function. + +

        + +

        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the collection of source ObservableSources
        +
        combiner - the aggregation function used to combine the items emitted by the returned ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T,R> @NonNull Observable<R> combineLatest(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
+        @NonNull Function<? super Object[],? extends R> combiner,
+        int bufferSize)
        +
        Combines an Iterable of source ObservableSources by emitting an item that aggregates the latest values of each of + the returned ObservableSources each time an item is received from any of the returned ObservableSources, where this + aggregation is defined by a specified function. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided Iterable of ObservableSources is empty, the resulting sequence completes immediately without emitting + any items and without any calls to the combiner function. + +

        + +

        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the collection of source ObservableSources
        +
        combiner - the aggregation function used to combine the items emitted by the returned ObservableSources
        +
        bufferSize - the expected number of row combination items to be buffered internally
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatestArray

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T,R> @NonNull Observable<R> combineLatestArray(@NonNull ObservableSource<? extends T>[] sources,
+        @NonNull Function<? super Object[],? extends R> combiner)
        +
        Combines an array of source ObservableSources by emitting an item that aggregates the latest values of each of + the ObservableSources each time an item is received from any of the returned ObservableSources, where this + aggregation is defined by a specified function. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided array of ObservableSources is empty, the resulting sequence completes immediately without emitting + any items and without any calls to the combiner function. + +

        + +

        +
        Scheduler:
        +
        combineLatestArray does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the collection of source ObservableSources
        +
        combiner - the aggregation function used to combine the items emitted by the ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatestArray

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T,R> @NonNull Observable<R> combineLatestArray(@NonNull ObservableSource<? extends T>[] sources,
+        @NonNull Function<? super Object[],? extends R> combiner,
+        int bufferSize)
        +
        Combines an array of source ObservableSources by emitting an item that aggregates the latest values of each of + the ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided array of ObservableSources is empty, the resulting sequence completes immediately without emitting + any items and without any calls to the combiner function. + +

        + +

        +
        Scheduler:
        +
        combineLatestArray does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the collection of source ObservableSources
        +
        combiner - the aggregation function used to combine the items emitted by the ObservableSources
        +
        bufferSize - the expected number of row combination items to be buffered internally
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull BiFunction<? super T1,? super T2,? extends R> combiner)
        +
        Combines two source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from either of the ObservableSources, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - the second source ObservableSource
        +
        combiner - the aggregation function used to combine the items emitted by the ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2 or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull ObservableSource<? extends T3> source3,
+        @NonNull Function3<? super T1,? super T2,? super T3,? extends R> combiner)
        +
        Combines three source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        T3 - the element type of the third source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - the second source ObservableSource
        +
        source3 - the third source ObservableSource
        +
        combiner - the aggregation function used to combine the items emitted by the ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3 or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull ObservableSource<? extends T3> source3,
+        @NonNull ObservableSource<? extends T4> source4,
+        @NonNull Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner)
        +
        Combines four source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        T3 - the element type of the third source
        +
        T4 - the element type of the fourth source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - the second source ObservableSource
        +
        source3 - the third source ObservableSource
        +
        source4 - the fourth source ObservableSource
        +
        combiner - the aggregation function used to combine the items emitted by the ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4 or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull ObservableSource<? extends T3> source3,
+        @NonNull ObservableSource<? extends T4> source4,
+        @NonNull ObservableSource<? extends T5> source5,
+        @NonNull Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> combiner)
        +
        Combines five source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        T3 - the element type of the third source
        +
        T4 - the element type of the fourth source
        +
        T5 - the element type of the fifth source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - the second source ObservableSource
        +
        source3 - the third source ObservableSource
        +
        source4 - the fourth source ObservableSource
        +
        source5 - the fifth source ObservableSource
        +
        combiner - the aggregation function used to combine the items emitted by the ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5 or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull ObservableSource<? extends T3> source3,
+        @NonNull ObservableSource<? extends T4> source4,
+        @NonNull ObservableSource<? extends T5> source5,
+        @NonNull ObservableSource<? extends T6> source6,
+        @NonNull Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> combiner)
        +
        Combines six source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        T3 - the element type of the third source
        +
        T4 - the element type of the fourth source
        +
        T5 - the element type of the fifth source
        +
        T6 - the element type of the sixth source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - the second source ObservableSource
        +
        source3 - the third source ObservableSource
        +
        source4 - the fourth source ObservableSource
        +
        source5 - the fifth source ObservableSource
        +
        source6 - the sixth source ObservableSource
        +
        combiner - the aggregation function used to combine the items emitted by the ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6 or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,T7,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull ObservableSource<? extends T3> source3,
+        @NonNull ObservableSource<? extends T4> source4,
+        @NonNull ObservableSource<? extends T5> source5,
+        @NonNull ObservableSource<? extends T6> source6,
+        @NonNull ObservableSource<? extends T7> source7,
+        @NonNull Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> combiner)
        +
        Combines seven source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        T3 - the element type of the third source
        +
        T4 - the element type of the fourth source
        +
        T5 - the element type of the fifth source
        +
        T6 - the element type of the sixth source
        +
        T7 - the element type of the seventh source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - the second source ObservableSource
        +
        source3 - the third source ObservableSource
        +
        source4 - the fourth source ObservableSource
        +
        source5 - the fifth source ObservableSource
        +
        source6 - the sixth source ObservableSource
        +
        source7 - the seventh source ObservableSource
        +
        combiner - the aggregation function used to combine the items emitted by the ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6, + source7 or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,T7,T8,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull ObservableSource<? extends T3> source3,
+        @NonNull ObservableSource<? extends T4> source4,
+        @NonNull ObservableSource<? extends T5> source5,
+        @NonNull ObservableSource<? extends T6> source6,
+        @NonNull ObservableSource<? extends T7> source7,
+        @NonNull ObservableSource<? extends T8> source8,
+        @NonNull Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> combiner)
        +
        Combines eight source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        T3 - the element type of the third source
        +
        T4 - the element type of the fourth source
        +
        T5 - the element type of the fifth source
        +
        T6 - the element type of the sixth source
        +
        T7 - the element type of the seventh source
        +
        T8 - the element type of the eighth source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - the second source ObservableSource
        +
        source3 - the third source ObservableSource
        +
        source4 - the fourth source ObservableSource
        +
        source5 - the fifth source ObservableSource
        +
        source6 - the sixth source ObservableSource
        +
        source7 - the seventh source ObservableSource
        +
        source8 - the eighth source ObservableSource
        +
        combiner - the aggregation function used to combine the items emitted by the ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6, + source7, source8 or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatest

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull ObservableSource<? extends T3> source3,
+        @NonNull ObservableSource<? extends T4> source4,
+        @NonNull ObservableSource<? extends T5> source5,
+        @NonNull ObservableSource<? extends T6> source6,
+        @NonNull ObservableSource<? extends T7> source7,
+        @NonNull ObservableSource<? extends T8> source8,
+        @NonNull ObservableSource<? extends T9> source9,
+        @NonNull Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> combiner)
        +
        Combines nine source ObservableSources by emitting an item that aggregates the latest values of each of the + ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + +

        +
        Scheduler:
        +
        combineLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the element type of the first source
        +
        T2 - the element type of the second source
        +
        T3 - the element type of the third source
        +
        T4 - the element type of the fourth source
        +
        T5 - the element type of the fifth source
        +
        T6 - the element type of the sixth source
        +
        T7 - the element type of the seventh source
        +
        T8 - the element type of the eighth source
        +
        T9 - the element type of the ninth source
        +
        R - the combined output type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - the second source ObservableSource
        +
        source3 - the third source ObservableSource
        +
        source4 - the fourth source ObservableSource
        +
        source5 - the fifth source ObservableSource
        +
        source6 - the sixth source ObservableSource
        +
        source7 - the seventh source ObservableSource
        +
        source8 - the eighth source ObservableSource
        +
        source9 - the ninth source ObservableSource
        +
        combiner - the aggregation function used to combine the items emitted by the ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6, + source7, source8, source9 or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatestArrayDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T,R> @NonNull Observable<R> combineLatestArrayDelayError(@NonNull ObservableSource<? extends T>[] sources,
+        @NonNull Function<? super Object[],? extends R> combiner)
        +
        Combines an array of ObservableSources by emitting an item that aggregates the latest values of each of + the ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function. +

        + +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided array of ObservableSources is empty, the resulting sequence completes immediately without emitting + any items and without any calls to the combiner function. + +

        +
        Scheduler:
        +
        combineLatestArrayDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the collection of source ObservableSources
        +
        combiner - the aggregation function used to combine the items emitted by the ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatestArrayDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T,R> @NonNull Observable<R> combineLatestArrayDelayError(@NonNull ObservableSource<? extends T>[] sources,
+        @NonNull Function<? super Object[],? extends R> combiner,
+        int bufferSize)
        +
        Combines an array of ObservableSources by emitting an item that aggregates the latest values of each of + the ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function and delays any error from the sources until + all source ObservableSources terminate. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided array of ObservableSources is empty, the resulting sequence completes immediately without emitting + any items and without any calls to the combiner function. + +

        + +

        +
        Scheduler:
        +
        combineLatestArrayDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the collection of source ObservableSources
        +
        combiner - the aggregation function used to combine the items emitted by the ObservableSources
        +
        bufferSize - the expected number of row combination items to be buffered internally
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatestDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T,R> @NonNull Observable<R> combineLatestDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
+        @NonNull Function<? super Object[],? extends R> combiner)
        +
        Combines an Iterable of ObservableSources by emitting an item that aggregates the latest values of each of + the ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function and delays any error from the sources until + all source ObservableSources terminate. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided iterable of ObservableSources is empty, the resulting sequence completes immediately without emitting + any items and without any calls to the combiner function. + +

        + +

        +
        Scheduler:
        +
        combineLatestDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the Iterable of source ObservableSources
        +
        combiner - the aggregation function used to combine the items emitted by the ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        combineLatestDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T,R> @NonNull Observable<R> combineLatestDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
+        @NonNull Function<? super Object[],? extends R> combiner,
+        int bufferSize)
        +
        Combines an Iterable of ObservableSources by emitting an item that aggregates the latest values of each of + the ObservableSources each time an item is received from any of the ObservableSources, where this + aggregation is defined by a specified function and delays any error from the sources until + all source ObservableSources terminate. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the sources never produces an item but only terminates (normally or with an error), the + resulting sequence terminates immediately (normally or with all the errors accumulated till that point). + If that input source is also synchronous, other sources after it will not be subscribed to. +

        + If the provided iterable of ObservableSources is empty, the resulting sequence completes immediately without emitting + any items and without any calls to the combiner function. + +

        + +

        +
        Scheduler:
        +
        combineLatestDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common base type of source values
        +
        R - the result type
        +
        Parameters:
        +
        sources - the collection of source ObservableSources
        +
        combiner - the aggregation function used to combine the items emitted by the ObservableSources
        +
        bufferSize - the expected number of row combination items to be buffered internally
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources or combiner is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        concatArrayEager

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+ @NonNull
+public static <T> @NonNull Observable<T> concatArrayEager(@NonNull ObservableSource<? extends T>... sources)
        +
        Concatenates an array of ObservableSources eagerly into a single stream of values. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them + in order, each one after the previous one completes. +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - an array of ObservableSources that need to be eagerly concatenated
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatArrayEager

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+ @SafeVarargs
+public static <T> @NonNull Observable<T> concatArrayEager(int maxConcurrency,
+        int bufferSize,
+        @NonNull ObservableSource<? extends T>... sources)
        +
        Concatenates an array of ObservableSources eagerly into a single stream of values. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them + in order, each one after the previous one completes. +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - an array of ObservableSources that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrent subscriptions at a time, Integer.MAX_VALUE + is interpreted as indication to subscribe to all sources at once
        +
        bufferSize - the number of elements expected from each ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatArrayEagerDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+ @NonNull
+public static <T> @NonNull Observable<T> concatArrayEagerDelayError(@NonNull ObservableSource<? extends T>... sources)
        +
        Concatenates an array of ObservableSources eagerly into a single stream of values + and delaying any errors until all sources terminate. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + ObservableSources. The operator buffers the values emitted by these ObservableSources + and then drains them in order, each one after the previous one completes. +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - an array of ObservableSources that need to be eagerly concatenated
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        2.2.1 - experimental
        +
        +
        • +
      + + + +
        +
      • +

        concatArrayEagerDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+ @SafeVarargs
+public static <T> @NonNull Observable<T> concatArrayEagerDelayError(int maxConcurrency,
+        int bufferSize,
+        @NonNull ObservableSource<? extends T>... sources)
        +
        Concatenates an array of ObservableSources eagerly into a single stream of values + and delaying any errors until all sources terminate. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + ObservableSources. The operator buffers the values emitted by these ObservableSources + and then drains them in order, each one after the previous one completes. +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - an array of ObservableSources that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrent subscriptions at a time, Integer.MAX_VALUE + is interpreted as indication to subscribe to all sources at once
        +
        bufferSize - the number of elements expected from each ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        Since:
        +
        2.2.1 - experimental
        +
        +
        • +
      + + + +
        +
      • +

        concatDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Observable<T> concatDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources)
        +
        Concatenates the Iterable sequence of ObservableSources into a single Observable sequence + by subscribing to each ObservableSource, one after the other, one at a time and delays any errors till + the all inner ObservableSources terminate. +

        + +

        +
        Scheduler:
        +
        concatDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable sequence of ObservableSources
        +
        Returns:
        +
        the new Observable with the concatenating behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        +
        • +
      + + + +
        +
      • +

        concatDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> concatDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources)
        +
        Concatenates the ObservableSource sequence of ObservableSources into a single Observable sequence + by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the + all inner and the outer ObservableSources terminate. +

        + +

        +
        Scheduler:
        +
        concatDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the ObservableSource sequence of ObservableSources
        +
        Returns:
        +
        the new Observable with the concatenating behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        +
        • +
      + + + +
        +
      • +

        concatDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Observable<T> concatDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources,
+        int bufferSize,
+        boolean tillTheEnd)
        +
        Concatenates the ObservableSource sequence of ObservableSources into a single sequence by subscribing to each inner ObservableSource, + one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate. +

        + +

        +
        Scheduler:
        +
        concatDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the ObservableSource sequence of ObservableSources
        +
        bufferSize - the number of inner ObservableSources expected to be buffered
        +
        tillTheEnd - if true, exceptions from the outer and all inner ObservableSources are delayed to the end + if false, exception from the outer ObservableSource is delayed till the active ObservableSource terminates
        +
        Returns:
        +
        the new Observable with the concatenating behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> concatEager(@NonNull Iterable<? extends ObservableSource<? extends T>> sources)
        +
        Concatenates a sequence of ObservableSources eagerly into a single stream of values. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them + in order, each one after the previous one completes. +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of ObservableSources that need to be eagerly concatenated
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> concatEager(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
+        int maxConcurrency,
+        int bufferSize)
        +
        Concatenates a sequence of ObservableSources eagerly into a single stream of values and + runs a limited number of inner sequences at once. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them + in order, each one after the previous one completes. +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of ObservableSources that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrently running inner ObservableSources; Integer.MAX_VALUE + is interpreted as all inner ObservableSources can be active at the same time
        +
        bufferSize - the number of elements expected from each inner ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> concatEager(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources)
        +
        Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source ObservableSources as they are observed. The operator buffers the values emitted by these + ObservableSources and then drains them in order, each one after the previous one completes. +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of ObservableSources that need to be eagerly concatenated
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> concatEager(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources,
+        int maxConcurrency,
+        int bufferSize)
        +
        Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values + and runs a limited number of inner sequences at once. + +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source ObservableSources as they are observed. The operator buffers the values emitted by these + ObservableSources and then drains them in order, each one after the previous one completes. +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of ObservableSources that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrently running inner ObservableSources; Integer.MAX_VALUE + is interpreted as all inner ObservableSources can be active at the same time
        +
        bufferSize - the number of inner ObservableSource expected to be buffered
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> concatEagerDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources)
        +
        Concatenates a sequence of ObservableSources eagerly into a single stream of values, + delaying errors until all the inner sequences terminate. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them + in order, each one after the previous one completes. +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of ObservableSources that need to be eagerly concatenated
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> concatEagerDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
+        int maxConcurrency,
+        int bufferSize)
        +
        Concatenates a sequence of ObservableSources eagerly into a single stream of values, + delaying errors until all the inner sequences terminate and runs a limited number of inner + sequences at once. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them + in order, each one after the previous one completes. +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of ObservableSources that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrently running inner ObservableSources; Integer.MAX_VALUE + is interpreted as all inner ObservableSources can be active at the same time
        +
        bufferSize - the number of elements expected from each inner ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> concatEagerDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources)
        +
        Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values, + delaying errors until all the inner and the outer sequence terminate. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source ObservableSources as they are observed. The operator buffers the values emitted by these + ObservableSources and then drains them in order, each one after the previous one completes. +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of ObservableSources that need to be eagerly concatenated
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> concatEagerDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources,
+        int maxConcurrency,
+        int bufferSize)
        +
        Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values, + delaying errors until all the inner and the outer sequence terminate and runs a limited number of inner sequences at once. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source ObservableSources as they are observed. The operator buffers the values emitted by these + ObservableSources and then drains them in order, each one after the previous one completes. +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of ObservableSources that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrently running inner ObservableSources; Integer.MAX_VALUE + is interpreted as all inner ObservableSources can be active at the same time
        +
        bufferSize - the number of inner ObservableSource expected to be buffered
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Observable<T> create(@NonNull ObservableOnSubscribe<T> source)
        +
        Provides an API (via a cold Observable) that bridges the reactive world with the callback-style world. +

        + Example: + 

        
+ Observable.<Event>create(emitter -> {
+     Callback listener = new Callback() {
+         @Override
+         public void onEvent(Event e) {
+             emitter.onNext(e);
+             if (e.isLast()) {
+                 emitter.onComplete();
+             }
+         }
+
+         @Override
+         public void onFailure(Exception e) {
+             emitter.onError(e);
+         }
+     };
+
+     AutoCloseable c = api.someMethod(listener);
+
+     emitter.setCancellable(c::close);
+
+ });
+
        +

        + Whenever an Observer subscribes to the returned Observable, the provided + ObservableOnSubscribe callback is invoked with a fresh instance of an ObservableEmitter + that will interact only with that specific Observer. If this Observer + disposes the flow (making ObservableEmitter.isDisposed() return true), + other observers subscribed to the same returned Observable are not affected. +

        + +

        + You should call the ObservableEmitter's onNext, onError and onComplete methods in a serialized fashion. The + rest of its methods are thread-safe. +

        +
        Scheduler:
        +
        create does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type
        +
        Parameters:
        +
        source - the emitter that is called when an Observer subscribes to the returned Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source is null
        +
        See Also:
        +
        ObservableOnSubscribe, +ObservableEmitter, +Cancellable
        +
        +
        • +
      + + + +
        +
      • +

        defer

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Observable<T> defer(@NonNull Supplier<? extends ObservableSource<? extends T>> supplier)
        +
        Returns an Observable that calls an ObservableSource factory to create an ObservableSource for each new Observer + that subscribes. That is, for each subscriber, the actual ObservableSource that subscriber observes is + determined by the factory function. +

        + +

        + The defer operator allows you to defer or delay emitting items from an ObservableSource until such time as an + Observer subscribes to the ObservableSource. This allows an Observer to easily obtain updates or a + refreshed version of the sequence. +

        +
        Scheduler:
        +
        defer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the type of the items emitted by the ObservableSource
        +
        Parameters:
        +
        supplier - the ObservableSource factory function to invoke for each Observer that subscribes to the + resulting Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if supplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: Defer
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        fromCallable

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Observable<T> fromCallable(@NonNull Callable<? extends T> callable)
        +
        Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then + emits the value returned from that function. +

        + +

        + This allows you to defer the execution of the function you specify until an observer subscribes to the + Observable. That is to say, it makes the function "lazy." +

        +
        Scheduler:
        +
        fromCallable does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the Callable throws an exception, the respective Throwable is + delivered to the downstream via Observer.onError(Throwable), + except when the downstream has disposed the current Observable source. + In this latter case, the Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) as an UndeliverableException. +
        +
        +
        +
        Type Parameters:
        +
        T - the type of the item returned by the Callable and emitted by the Observable
        +
        Parameters:
        +
        callable - a function, the execution of which should be deferred; fromCallable will invoke this + function only when an observer subscribes to the Observable that fromCallable returns
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if callable is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        defer(Supplier), +fromSupplier(Supplier)
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        fromMaybe

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Observable<T> fromMaybe(@NonNull MaybeSource<T> maybe)
        +
        Returns an Observable instance that when subscribed to, subscribes to the MaybeSource instance and + emits onSuccess as a single item or forwards any onComplete or + onError signal. +

        + +

        +
        Scheduler:
        +
        fromMaybe does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type of the MaybeSource element
        +
        Parameters:
        +
        maybe - the MaybeSource instance to subscribe to, not null
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if maybe is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + + + + + +
        +
      • +

        fromRunnable

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Observable<T> fromRunnable(@NonNull Runnable run)
        +
        Returns an Observable instance that runs the given Runnable for each Observer and + emits either its unchecked exception or simply completes. +

        + +

        + If the code to be wrapped needs to throw a checked or more broader Throwable exception, that + exception has to be converted to an unchecked exception by the wrapped code itself. Alternatively, + use the fromAction(Action) method which allows the wrapped code to throw any Throwable + exception and will signal it to observers as-is. +

        +
        Scheduler:
        +
        fromRunnable does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the Runnable throws an exception, the respective Throwable is + delivered to the downstream via Observer.onError(Throwable), + except when the downstream has canceled the resulting Observable source. + In this latter case, the Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) as an UndeliverableException. +
        +
        +
        +
        Type Parameters:
        +
        T - the target type
        +
        Parameters:
        +
        run - the Runnable to run for each Observer
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if run is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        fromAction(Action)
        +
        +
        • +
      + + + +
        +
      • +

        fromSingle

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Observable<T> fromSingle(@NonNull SingleSource<T> source)
        +
        Returns an Observable instance that when subscribed to, subscribes to the SingleSource instance and + emits onSuccess as a single item or forwards the onError signal. +

        + +

        +
        Scheduler:
        +
        fromSingle does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type of the SingleSource element
        +
        Parameters:
        +
        source - the SingleSource instance to subscribe to, not null
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        fromSupplier

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Observable<T> fromSupplier(@NonNull Supplier<? extends T> supplier)
        +
        Returns an Observable that, when an observer subscribes to it, invokes a supplier function you specify and then + emits the value returned from that function. +

        + +

        + This allows you to defer the execution of the function you specify until an observer subscribes to the + Observable. That is to say, it makes the function "lazy." +

        +
        Scheduler:
        +
        fromSupplier does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the Supplier throws an exception, the respective Throwable is + delivered to the downstream via Observer.onError(Throwable), + except when the downstream has disposed the current Observable source. + In this latter case, the Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) as an UndeliverableException. +
        +
        +
        +
        Type Parameters:
        +
        T - the type of the item emitted by the Observable
        +
        Parameters:
        +
        supplier - a function, the execution of which should be deferred; fromSupplier will invoke this + function only when an observer subscribes to the Observable that fromSupplier returns
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if supplier is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        defer(Supplier), +fromCallable(Callable)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        generate

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T,S> @NonNull Observable<T> generate(@NonNull Supplier<S> initialState,
+        @NonNull BiConsumer<S,Emitter<T>> generator)
        +
        Returns a cold, synchronous and stateful generator of values. +

        + +

        + Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and + Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, + never concurrently and only while the function body is executing. Calling them from multiple threads + or outside the function call is not supported and leads to an undefined behavior. +

        +
        Scheduler:
        +
        generate does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        S - the type of the per-Observer state
        +
        T - the generated value type
        +
        Parameters:
        +
        initialState - the Supplier to generate the initial state for each Observer
        +
        generator - the BiConsumer called in a loop after a downstream Observer has + subscribed. The callback then should call onNext, onError or + onComplete to signal a value or a terminal event. Signaling multiple onNext + in a call will make the operator signal IllegalStateException.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if initialState or generator is null
        +
        +
        • +
      + + + +
        +
      • +

        generate

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T,S> @NonNull Observable<T> generate(@NonNull Supplier<S> initialState,
+        @NonNull BiConsumer<S,Emitter<T>> generator,
+        @NonNull Consumer<? super S> disposeState)
        +
        Returns a cold, synchronous and stateful generator of values. +

        + +

        + Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and + Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, + never concurrently and only while the function body is executing. Calling them from multiple threads + or outside the function call is not supported and leads to an undefined behavior. +

        +
        Scheduler:
        +
        generate does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        S - the type of the per-Observer state
        +
        T - the generated value type
        +
        Parameters:
        +
        initialState - the Supplier to generate the initial state for each Observer
        +
        generator - the BiConsumer called in a loop after a downstream Observer has + subscribed. The callback then should call onNext, onError or + onComplete to signal a value or a terminal event. Signaling multiple onNext + in a call will make the operator signal IllegalStateException.
        +
        disposeState - the Consumer that is called with the current state when the generator + terminates the sequence or it gets disposed
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if initialState, generator or disposeState is null
        +
        +
        • +
      + + + +
        +
      • +

        generate

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T,S> @NonNull Observable<T> generate(@NonNull Supplier<S> initialState,
+        @NonNull BiFunction<S,Emitter<T>,S> generator)
        +
        Returns a cold, synchronous and stateful generator of values. +

        + +

        + Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and + Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, + never concurrently and only while the function body is executing. Calling them from multiple threads + or outside the function call is not supported and leads to an undefined behavior. +

        +
        Scheduler:
        +
        generate does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        S - the type of the per-Observer state
        +
        T - the generated value type
        +
        Parameters:
        +
        initialState - the Supplier to generate the initial state for each Observer
        +
        generator - the BiConsumer called in a loop after a downstream Observer has + subscribed. The callback then should call onNext, onError or + onComplete to signal a value or a terminal event and should return a (new) state for + the next invocation. Signaling multiple onNext + in a call will make the operator signal IllegalStateException.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if initialState or generator is null
        +
        +
        • +
      + + + +
        +
      • +

        generate

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T,S> @NonNull Observable<T> generate(@NonNull Supplier<S> initialState,
+        @NonNull BiFunction<S,Emitter<T>,S> generator,
+        @NonNull Consumer<? super S> disposeState)
        +
        Returns a cold, synchronous and stateful generator of values. +

        + +

        + Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and + Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, + never concurrently and only while the function body is executing. Calling them from multiple threads + or outside the function call is not supported and leads to an undefined behavior. +

        +
        Scheduler:
        +
        generate does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        S - the type of the per-Observer state
        +
        T - the generated value type
        +
        Parameters:
        +
        initialState - the Supplier to generate the initial state for each Observer
        +
        generator - the BiConsumer called in a loop after a downstream Observer has + subscribed. The callback then should call onNext, onError or + onComplete to signal a value or a terminal event and should return a (new) state for + the next invocation. Signaling multiple onNext + in a call will make the operator signal IllegalStateException.
        +
        disposeState - the Consumer that is called with the current state when the generator + terminates the sequence or it gets disposed
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if initialState, generator or disposeState is null
        +
        +
        • +
      + + + +
        +
      • +

        interval

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public static @NonNull Observable<Long> interval(long initialDelay,
+        long period,
+        @NonNull TimeUnit unit)
        +
        Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers + after each period of time thereafter. +

        + +

        +
        Scheduler:
        +
        interval operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        initialDelay - the initial delay time to wait before emitting the first value of 0L
        +
        period - the period of time between emissions of the subsequent numbers
        +
        unit - the time unit for both initialDelay and period
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        1.0.12
        +
        See Also:
        +
        ReactiveX operators documentation: Interval
        +
        +
        • +
      + + + +
        +
      • +

        interval

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="custom")
+public static @NonNull Observable<Long> interval(long initialDelay,
+        long period,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers + after each period of time thereafter, on a specified Scheduler. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        initialDelay - the initial delay time to wait before emitting the first value of 0L
        +
        period - the period of time between emissions of the subsequent numbers
        +
        unit - the time unit for both initialDelay and period
        +
        scheduler - the Scheduler on which the waiting happens and items are emitted
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        Since:
        +
        1.0.12
        +
        See Also:
        +
        ReactiveX operators documentation: Interval
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        intervalRange

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="io.reactivex:computation")
+public static @NonNull Observable<Long> intervalRange(long start,
+        long count,
+        long initialDelay,
+        long period,
+        @NonNull TimeUnit unit)
        +
        Signals a range of long values, the first after some initial delay and the rest periodically after. +

        + The sequence completes immediately after the last value (start + count - 1) has been reached. +

        + +

        +
        Scheduler:
        +
        intervalRange by default operates on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        start - that start value of the range
        +
        count - the number of values to emit in total, if zero, the operator emits an onComplete after the initial delay.
        +
        initialDelay - the initial delay before signaling the first value (the start)
        +
        period - the period between subsequent values
        +
        unit - the unit of measure of the initialDelay and period amounts
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        IllegalArgumentException - if count is negative, or if start + count − 1 exceeds + Long.MAX_VALUE
        +
        See Also:
        +
        range(int, int)
        +
        +
        • +
      + + + +
        +
      • +

        intervalRange

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="custom")
+public static @NonNull Observable<Long> intervalRange(long start,
+        long count,
+        long initialDelay,
+        long period,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Signals a range of long values, the first after some initial delay and the rest periodically after. +

        + The sequence completes immediately after the last value (start + count - 1) has been reached. +

        + *

        +
        Scheduler:
        +
        you provide the Scheduler.
        +
        +
        +
        Parameters:
        +
        start - that start value of the range
        +
        count - the number of values to emit in total, if zero, the operator emits an onComplete after the initial delay.
        +
        initialDelay - the initial delay before signaling the first value (the start)
        +
        period - the period between subsequent values
        +
        unit - the unit of measure of the initialDelay and period amounts
        +
        scheduler - the target scheduler where the values and terminal signals will be emitted
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if count is negative, or if start + count − 1 exceeds + Long.MAX_VALUE
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> merge(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
+        int maxConcurrency,
+        int bufferSize)
        +
        Flattens an Iterable of ObservableSources into one Observable, without any transformation, while limiting the + number of concurrent subscriptions to these ObservableSources. +

        + +

        + You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + using the merge method. +

        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the returned ObservableSources signal a Throwable via onError, the resulting + Observable terminates with that Throwable and all other source ObservableSources are disposed. + If more than one ObservableSource signals an error, the resulting Observable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Observable has been disposed or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(Iterable, int, int) to merge sources and terminate only when all source ObservableSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable of ObservableSources
        +
        maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently
        +
        bufferSize - the number of items expected from each inner ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeDelayError(Iterable, int, int)
        +
        +
        • +
      + + + +
        +
      • +

        mergeArray

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+ @SafeVarargs
+public static <T> @NonNull Observable<T> mergeArray(int maxConcurrency,
+        int bufferSize,
+        @NonNull ObservableSource<? extends T>... sources)
        +
        Flattens an array of ObservableSources into one Observable, without any transformation, while limiting the + number of concurrent subscriptions to these ObservableSources. +

        + +

        + You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + using the merge method. +

        +
        Scheduler:
        +
        mergeArray does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the ObservableSources signal a Throwable via onError, the resulting + Observable terminates with that Throwable and all other source ObservableSources are disposed. + If more than one ObservableSource signals an error, the resulting Observable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Observable has been disposed or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeArrayDelayError(int, int, ObservableSource...) to merge sources and terminate only when all source ObservableSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the array of ObservableSources
        +
        maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently
        +
        bufferSize - the number of items expected from each inner ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeArrayDelayError(int, int, ObservableSource...)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> merge(@NonNull Iterable<? extends ObservableSource<? extends T>> sources)
        +
        Flattens an Iterable of ObservableSources into one Observable, without any transformation. +

        + +

        + You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + using the merge method. +

        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the returned ObservableSources signal a Throwable via onError, the resulting + Observable terminates with that Throwable and all other source ObservableSources are disposed. + If more than one ObservableSource signals an error, the resulting Observable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Observable has been disposed or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(Iterable) to merge sources and terminate only when all source ObservableSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable of ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeDelayError(Iterable)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> merge(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
+        int maxConcurrency)
        +
        Flattens an Iterable of ObservableSources into one Observable, without any transformation, while limiting the + number of concurrent subscriptions to these ObservableSources. +

        + +

        + You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + using the merge method. +

        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the returned ObservableSources signal a Throwable via onError, the resulting + Observable terminates with that Throwable and all other source ObservableSources are disposed. + If more than one ObservableSource signals an error, the resulting Observable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Observable has been disposed or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(Iterable, int) to merge sources and terminate only when all source ObservableSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable of ObservableSources
        +
        maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is less than or equal to 0
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeDelayError(Iterable, int)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> merge(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources)
        +
        Flattens an ObservableSource that emits ObservableSources into a single Observable that emits the items emitted by + those ObservableSources, without any transformation. +

        + +

        + You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + using the merge method. +

        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the returned ObservableSources signal a Throwable via onError, the resulting + Observable terminates with that Throwable and all other source ObservableSources are disposed. + If more than one ObservableSource signals an error, the resulting Observable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Observable has been disposed or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(ObservableSource) to merge sources and terminate only when all source ObservableSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - an ObservableSource that emits ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeDelayError(ObservableSource)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> merge(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources,
+        int maxConcurrency)
        +
        Flattens an ObservableSource that emits ObservableSources into a single Observable that emits the items emitted by + those ObservableSources, without any transformation, while limiting the maximum number of concurrent + subscriptions to these ObservableSources. +

        + +

        + You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + using the merge method. +

        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the returned ObservableSources signal a Throwable via onError, the resulting + Observable terminates with that Throwable and all other source ObservableSources are disposed. + If more than one ObservableSource signals an error, the resulting Observable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Observable has been disposed or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(ObservableSource, int) to merge sources and terminate only when all source ObservableSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - an ObservableSource that emits ObservableSources
        +
        maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        1.1.0
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeDelayError(ObservableSource, int)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> merge(@NonNull ObservableSource<? extends T> source1,
+        @NonNull ObservableSource<? extends T> source2)
        +
        Flattens two ObservableSources into a single Observable, without any transformation. +

        + +

        + You can combine items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + using the merge method. +

        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the ObservableSources signal a Throwable via onError, the resulting + Observable terminates with that Throwable and all other source ObservableSources are disposed. + If more than one ObservableSource signals an error, the resulting Observable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Observable has been disposed or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(ObservableSource, ObservableSource) to merge sources and terminate only when all source ObservableSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        source1 - an ObservableSource to be merged
        +
        source2 - an ObservableSource to be merged
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1 or source2 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeDelayError(ObservableSource, ObservableSource)
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        mergeArray

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+ @SafeVarargs
+public static <T> @NonNull Observable<T> mergeArray(@NonNull ObservableSource<? extends T>... sources)
        +
        Flattens an array of ObservableSources into one Observable, without any transformation. +

        + +

        + You can combine items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + using the merge method. +

        +
        Scheduler:
        +
        mergeArray does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the ObservableSources signal a Throwable via onError, the resulting + Observable terminates with that Throwable and all other source ObservableSources are disposed. + If more than one ObservableSource signals an error, the resulting Observable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Observable has been disposed or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeArrayDelayError(ObservableSource...) to merge sources and terminate only when all source ObservableSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the array of ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeArrayDelayError(ObservableSource...)
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> mergeDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources)
        +
        Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all + successfully emitted items from each of the returned ObservableSources without being interrupted by an error + notification from one of them. +

        + This behaves like merge(ObservableSource) except that if any of the merged ObservableSources notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged ObservableSources have finished emitting items. +

        + +

        + Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only + invoke the onError method of its Observers once. +

        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable of ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> mergeDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
+        int maxConcurrency,
+        int bufferSize)
        +
        Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all + successfully emitted items from each of the returned ObservableSources without being interrupted by an error + notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources. +

        + This behaves like merge(ObservableSource) except that if any of the merged ObservableSources notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged ObservableSources have finished emitting items. +

        + +

        + Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only + invoke the onError method of its Observers once. +

        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable of ObservableSources
        +
        maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently
        +
        bufferSize - the number of items expected from each inner ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeArrayDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+ @SafeVarargs
+public static <T> @NonNull Observable<T> mergeArrayDelayError(int maxConcurrency,
+        int bufferSize,
+        @NonNull ObservableSource<? extends T>... sources)
        +
        Flattens an array of ObservableSources into one Observable, in a way that allows an Observer to receive all + successfully emitted items from each of the ObservableSources without being interrupted by an error + notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources. +

        + This behaves like merge(ObservableSource) except that if any of the merged ObservableSources notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged ObservableSources have finished emitting items. +

        + +

        + Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only + invoke the onError method of its Observers once. +

        +
        Scheduler:
        +
        mergeArrayDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the array of ObservableSources
        +
        maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently
        +
        bufferSize - the number of items expected from each inner ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> mergeDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
+        int maxConcurrency)
        +
        Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all + successfully emitted items from each of the returned ObservableSources without being interrupted by an error + notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources. +

        + This behaves like merge(ObservableSource) except that if any of the merged ObservableSources notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged ObservableSources have finished emitting items. +

        + +

        + Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only + invoke the onError method of its Observers once. +

        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable of ObservableSources
        +
        maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> mergeDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources)
        +
        Flattens an ObservableSource that emits ObservableSources into one Observable, in a way that allows an Observer to + receive all successfully emitted items from all of the emitted ObservableSources without being interrupted by + an error notification from one of them. +

        + This behaves like merge(ObservableSource) except that if any of the merged ObservableSources notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged ObservableSources have finished emitting items. +

        + +

        + Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only + invoke the onError method of its Observers once. +

        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - an ObservableSource that emits ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> mergeDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources,
+        int maxConcurrency)
        +
        Flattens an ObservableSource that emits ObservableSources into one Observable, in a way that allows an Observer to + receive all successfully emitted items from all of the emitted ObservableSources without being interrupted by + an error notification from one of them, while limiting the + number of concurrent subscriptions to these ObservableSources. +

        + This behaves like merge(ObservableSource) except that if any of the merged ObservableSources notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged ObservableSources have finished emitting items. +

        + +

        + Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only + invoke the onError method of its Observers once. +

        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - an ObservableSource that emits ObservableSources
        +
        maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        mergeDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> mergeDelayError(@NonNull ObservableSource<? extends T> source1,
+        @NonNull ObservableSource<? extends T> source2)
        +
        Flattens two ObservableSources into one Observable, in a way that allows an Observer to receive all + successfully emitted items from each of the ObservableSources without being interrupted by an error + notification from one of them. +

        + This behaves like merge(ObservableSource, ObservableSource) except that if any of the merged ObservableSources + notify of an error via onError, mergeDelayError will refrain from + propagating that error notification until all of the merged ObservableSources have finished emitting items. +

        + +

        + Even if both merged ObservableSources send onError notifications, mergeDelayError will only + invoke the onError method of its Observers once. +

        +
        Scheduler:
        +
        mergeDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        source1 - an ObservableSource to be merged
        +
        source2 - an ObservableSource to be merged
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1 or source2 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        mergeArrayDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+ @SafeVarargs
+public static <T> @NonNull Observable<T> mergeArrayDelayError(@NonNull ObservableSource<? extends T>... sources)
        +
        Flattens an array of ObservableSources into one Observable, in a way that allows an Observer to receive all + successfully emitted items from each of the ObservableSources without being interrupted by an error + notification from one of them. +

        + This behaves like merge(ObservableSource) except that if any of the merged ObservableSources notify of an + error via onError, mergeDelayError will refrain from propagating that + error notification until all of the merged ObservableSources have finished emitting items. +

        + +

        + Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only + invoke the onError method of its Observers once. +

        +
        Scheduler:
        +
        mergeArrayDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the array of ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        switchOnNext

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> switchOnNext(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources,
+        int bufferSize)
        +
        Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the + most recently emitted of those ObservableSources. +

        + +

        + switchOnNext subscribes to an ObservableSource that emits ObservableSources. Each time it observes one of + these emitted ObservableSources, the ObservableSource returned by switchOnNext begins emitting the items + emitted by that ObservableSource. When a new inner ObservableSource is emitted, switchOnNext stops emitting items + from the earlier-emitted ObservableSource and begins emitting items from the new one. +

        + The resulting Observable completes if both the outer ObservableSource and the last inner ObservableSource, if any, complete. + If the outer ObservableSource signals an onError, the inner ObservableSource is disposed and the error delivered in-sequence. +

        +
        Scheduler:
        +
        switchOnNext does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the item type
        +
        Parameters:
        +
        sources - the ObservableSource that emits ObservableSources
        +
        bufferSize - the expected number of items to cache from the inner ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Switch
        +
        +
        • +
      + + + +
        +
      • +

        switchOnNext

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> switchOnNext(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources)
        +
        Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the + most recently emitted of those ObservableSources. +

        + +

        + switchOnNext subscribes to an ObservableSource that emits ObservableSources. Each time it observes one of + these emitted ObservableSources, the ObservableSource returned by switchOnNext begins emitting the items + emitted by that ObservableSource. When a new inner ObservableSource is emitted, switchOnNext stops emitting items + from the earlier-emitted ObservableSource and begins emitting items from the new one. +

        + The resulting Observable completes if both the outer ObservableSource and the last inner ObservableSource, if any, complete. + If the outer ObservableSource signals an onError, the inner ObservableSource is disposed and the error delivered in-sequence. +

        +
        Scheduler:
        +
        switchOnNext does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the item type
        +
        Parameters:
        +
        sources - the ObservableSource that emits ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Switch
        +
        +
        • +
      + + + +
        +
      • +

        switchOnNextDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> switchOnNextDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources)
        +
        Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the + most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate. +

        + +

        + switchOnNext subscribes to an ObservableSource that emits ObservableSources. Each time it observes one of + these emitted ObservableSources, the ObservableSource returned by switchOnNext begins emitting the items + emitted by that ObservableSource. When a new inner ObservableSource is emitted, switchOnNext stops emitting items + from the earlier-emitted ObservableSource and begins emitting items from the new one. +

        + The resulting Observable completes if both the main ObservableSource and the last inner ObservableSource, if any, complete. + If the main ObservableSource signals an onError, the termination of the last inner ObservableSource will emit that error as is + or wrapped into a CompositeException along with the other possible errors the former inner ObservableSources signaled. +

        +
        Scheduler:
        +
        switchOnNextDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the item type
        +
        Parameters:
        +
        sources - the ObservableSource that emits ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: Switch
        +
        +
        • +
      + + + +
        +
      • +

        switchOnNextDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> switchOnNextDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources,
+        int bufferSize)
        +
        Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the + most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate. +

        + +

        + switchOnNext subscribes to an ObservableSource that emits ObservableSources. Each time it observes one of + these emitted ObservableSources, the ObservableSource returned by switchOnNext begins emitting the items + emitted by that ObservableSource. When a new inner ObservableSource is emitted, switchOnNext stops emitting items + from the earlier-emitted ObservableSource and begins emitting items from the new one. +

        + The resulting Observable completes if both the main ObservableSource and the last inner ObservableSource, if any, complete. + If the main ObservableSource signals an onError, the termination of the last inner ObservableSource will emit that error as is + or wrapped into a CompositeException along with the other possible errors the former inner ObservableSources signaled. +

        +
        Scheduler:
        +
        switchOnNextDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the item type
        +
        Parameters:
        +
        sources - the ObservableSource that emits ObservableSources
        +
        bufferSize - the expected number of items to cache from the inner ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: Switch
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        using

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T,D> @NonNull Observable<T> using(@NonNull Supplier<? extends D> resourceSupplier,
+        @NonNull Function<? super D,? extends ObservableSource<? extends T>> sourceSupplier,
+        @NonNull Consumer<? super D> resourceCleanup)
        +
        Constructs an Observable that creates a dependent resource object, an ObservableSource with + that resource and calls the provided resourceDisposer function if this inner source terminates or the + downstream disposes the flow. +

        + +

        +
        Scheduler:
        +
        using does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the generated Observable
        +
        D - the type of the resource associated with the output sequence
        +
        Parameters:
        +
        resourceSupplier - the factory function to create a resource object that depends on the ObservableSource
        +
        sourceSupplier - the factory function to create an ObservableSource
        +
        resourceCleanup - the function that will dispose of the resource
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if resourceSupplier, sourceSupplier or resourceCleanup is null
        +
        See Also:
        +
        ReactiveX operators documentation: Using
        +
        +
        • +
      + + + +
        +
      • +

        using

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T,D> @NonNull Observable<T> using(@NonNull Supplier<? extends D> resourceSupplier,
+        @NonNull Function<? super D,? extends ObservableSource<? extends T>> sourceSupplier,
+        @NonNull Consumer<? super D> resourceCleanup,
+        boolean eager)
        +
        Constructs an Observable that creates a dependent resource object, an ObservableSource with + that resource and calls the provided disposer function if this inner source terminates or the + downstream disposes the flow; doing it before these end-states have been reached if eager == true, after otherwise. +

        + +

        +
        Scheduler:
        +
        using does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the generated ObservableSource
        +
        D - the type of the resource associated with the output sequence
        +
        Parameters:
        +
        resourceSupplier - the factory function to create a resource object that depends on the ObservableSource
        +
        sourceSupplier - the factory function to create an ObservableSource
        +
        resourceCleanup - the function that will dispose of the resource
        +
        eager - If true, the resource disposal will happen either on a dispose() call before the upstream is disposed + or just before the emission of a terminal event (onComplete or onError). + If false, the resource disposal will happen either on a dispose() call after the upstream is disposed + or just after the emission of a terminal event (onComplete or onError).
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if resourceSupplier, sourceSupplier and resourceCleanup is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: Using
        +
        +
        • +
      + + + + + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T,R> @NonNull Observable<R> zip(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
+        @NonNull Function<? super Object[],? extends R> zipper)
        +
        Returns an Observable that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an Iterable of other ObservableSources. +

        + zip applies this function in strict sequence, so the first item emitted by the resulting Observable + will be the result of the function applied to the first item emitted by each of the ObservableSources; + the second item emitted by the resulting Observable will be the result of the function applied to the second + item emitted by each of those ObservableSources; and so forth. +

        + The resulting Observable<R> returned from zip will invoke onNext as many times as + the number of onNext invocations of the ObservableSource that emits the fewest items. +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        zip(Arrays.asList(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)), (a) -> a)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. + +

        + +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common value type
        +
        R - the zipped result type
        +
        Parameters:
        +
        sources - an Iterable of source ObservableSources
        +
        zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in + an item that will be emitted by the resulting Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T,R> @NonNull Observable<R> zip(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
+        @NonNull Function<? super Object[],? extends R> zipper,
+        boolean delayError,
+        int bufferSize)
        +
        Returns an Observable that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an Iterable of other ObservableSources. +

        + zip applies this function in strict sequence, so the first item emitted by the resulting Observable + will be the result of the function applied to the first item emitted by each of the ObservableSources; + the second item emitted by the resulting Observable will be the result of the function applied to the second + item emitted by each of those ObservableSources; and so forth. +

        + The resulting Observable<R> returned from zip will invoke onNext as many times as + the number of onNext invocations of the ObservableSource that emits the fewest items. +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        zip(Arrays.asList(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)), (a) -> a)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. + +

        + +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common source value type
        +
        R - the zipped result type
        +
        Parameters:
        +
        sources - an Iterable of source ObservableSources
        +
        zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in + an item that will be emitted by the resulting Observable
        +
        delayError - delay errors signaled by any of the ObservableSource until all ObservableSources terminate
        +
        bufferSize - the number of elements expected from each source ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources or zipper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T1,T2,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull BiFunction<? super T1,? super T2,? extends R> zipper)
        +
        Returns an Observable that emits the results of a specified combiner function applied to combinations of + two items emitted, in sequence, by two other ObservableSources. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the resulting Observable + will be the result of the function applied to the first item emitted by o1 and the first item + emitted by o2; the second item emitted by the resulting Observable will be the result of the function + applied to the second item emitted by o1 and the second item emitted by o2; and so forth. +

        + The resulting Observable<R> returned from zip will invoke onNext + as many times as the number of onNext invocations of the ObservableSource that emits the fewest + items. +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), (a, b) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - a second source ObservableSource
        +
        zipper - a function that, when applied to an item emitted by each of the ObservableSources, results + in an item that will be emitted by the resulting Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T1,T2,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull BiFunction<? super T1,? super T2,? extends R> zipper,
+        boolean delayError)
        +
        Returns an Observable that emits the results of a specified combiner function applied to combinations of + two items emitted, in sequence, by two other ObservableSources. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the resulting Observable + will be the result of the function applied to the first item emitted by o1 and the first item + emitted by o2; the second item emitted by the resulting Observable will be the result of the function + applied to the second item emitted by o1 and the second item emitted by o2; and so forth. +

        + The resulting Observable<R> returned from zip will invoke onNext + as many times as the number of onNext invocations of the ObservableSource that emits the fewest + items. +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), (a, b) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - a second source ObservableSource
        +
        zipper - a function that, when applied to an item emitted by each of the ObservableSources, results + in an item that will be emitted by the resulting Observable
        +
        delayError - delay errors from any of the ObservableSources till the other terminates
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T1,T2,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull BiFunction<? super T1,? super T2,? extends R> zipper,
+        boolean delayError,
+        int bufferSize)
        +
        Returns an Observable that emits the results of a specified combiner function applied to combinations of + two items emitted, in sequence, by two other ObservableSources. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the resulting Observable + will be the result of the function applied to the first item emitted by o1 and the first item + emitted by o2; the second item emitted by the resulting Observable will be the result of the function + applied to the second item emitted by o1 and the second item emitted by o2; and so forth. +

        + The resulting Observable<R> returned from zip will invoke onNext + as many times as the number of onNext invocations of the ObservableSource that emits the fewest + items. +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), (a, b) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - a second source ObservableSource
        +
        zipper - a function that, when applied to an item emitted by each of the ObservableSources, results + in an item that will be emitted by the resulting Observable
        +
        delayError - delay errors from any of the ObservableSources till the other terminates
        +
        bufferSize - the number of elements expected from each source ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2 or zipper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T1,T2,T3,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull ObservableSource<? extends T3> source3,
+        @NonNull Function3<? super T1,? super T2,? super T3,? extends R> zipper)
        +
        Returns an Observable that emits the results of a specified combiner function applied to combinations of + three items emitted, in sequence, by three other ObservableSources. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the resulting Observable + will be the result of the function applied to the first item emitted by o1, the first item + emitted by o2, and the first item emitted by o3; the second item emitted by the resulting + Observable will be the result of the function applied to the second item emitted by o1, the + second item emitted by o2, and the second item emitted by o3; and so forth. +

        + The resulting Observable<R> returned from zip will invoke onNext + as many times as the number of onNext invocations of the ObservableSource that emits the fewest + items. +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - a second source ObservableSource
        +
        source3 - a third source ObservableSource
        +
        zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in + an item that will be emitted by the resulting Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T1,T2,T3,T4,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull ObservableSource<? extends T3> source3,
+        @NonNull ObservableSource<? extends T4> source4,
+        @NonNull Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)
        +
        Returns an Observable that emits the results of a specified combiner function applied to combinations of + four items emitted, in sequence, by four other ObservableSources. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the resulting Observable + will be the result of the function applied to the first item emitted by o1, the first item + emitted by o2, the first item emitted by o3, and the first item emitted by 04; + the second item emitted by the resulting Observable will be the result of the function applied to the second + item emitted by each of those ObservableSources; and so forth. +

        + The resulting Observable<R> returned from zip will invoke onNext + as many times as the number of onNext invocations of the ObservableSource that emits the fewest + items. +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - a second source ObservableSource
        +
        source3 - a third source ObservableSource
        +
        source4 - a fourth source ObservableSource
        +
        zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in + an item that will be emitted by the resulting Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T1,T2,T3,T4,T5,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull ObservableSource<? extends T3> source3,
+        @NonNull ObservableSource<? extends T4> source4,
+        @NonNull ObservableSource<? extends T5> source5,
+        @NonNull Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)
        +
        Returns an Observable that emits the results of a specified combiner function applied to combinations of + five items emitted, in sequence, by five other ObservableSources. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the resulting Observable + will be the result of the function applied to the first item emitted by o1, the first item + emitted by o2, the first item emitted by o3, the first item emitted by o4, and + the first item emitted by o5; the second item emitted by the resulting Observable will be the result of + the function applied to the second item emitted by each of those ObservableSources; and so forth. +

        + The resulting Observable<R> returned from zip will invoke onNext + as many times as the number of onNext invocations of the ObservableSource that emits the fewest + items. +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        T5 - the value type of the fifth source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - a second source ObservableSource
        +
        source3 - a third source ObservableSource
        +
        source4 - a fourth source ObservableSource
        +
        source5 - a fifth source ObservableSource
        +
        zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in + an item that will be emitted by the resulting Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T1,T2,T3,T4,T5,T6,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull ObservableSource<? extends T3> source3,
+        @NonNull ObservableSource<? extends T4> source4,
+        @NonNull ObservableSource<? extends T5> source5,
+        @NonNull ObservableSource<? extends T6> source6,
+        @NonNull Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)
        +
        Returns an Observable that emits the results of a specified combiner function applied to combinations of + six items emitted, in sequence, by six other ObservableSources. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the resulting Observable + will be the result of the function applied to the first item emitted by each source ObservableSource, the + second item emitted by the resulting Observable will be the result of the function applied to the second item + emitted by each of those ObservableSources, and so forth. +

        + The resulting Observable<R> returned from zip will invoke onNext + as many times as the number of onNext invocations of the ObservableSource that emits the fewest + items. +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        T5 - the value type of the fifth source
        +
        T6 - the value type of the sixth source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - a second source ObservableSource
        +
        source3 - a third source ObservableSource
        +
        source4 - a fourth source ObservableSource
        +
        source5 - a fifth source ObservableSource
        +
        source6 - a sixth source ObservableSource
        +
        zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in + an item that will be emitted by the resulting Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T1,T2,T3,T4,T5,T6,T7,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull ObservableSource<? extends T3> source3,
+        @NonNull ObservableSource<? extends T4> source4,
+        @NonNull ObservableSource<? extends T5> source5,
+        @NonNull ObservableSource<? extends T6> source6,
+        @NonNull ObservableSource<? extends T7> source7,
+        @NonNull Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)
        +
        Returns an Observable that emits the results of a specified combiner function applied to combinations of + seven items emitted, in sequence, by seven other ObservableSources. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the resulting Observable + will be the result of the function applied to the first item emitted by each source ObservableSource, the + second item emitted by the resulting Observable will be the result of the function applied to the second item + emitted by each of those ObservableSources, and so forth. +

        + The resulting Observable<R> returned from zip will invoke onNext + as many times as the number of onNext invocations of the ObservableSource that emits the fewest + items. +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f, g) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        T5 - the value type of the fifth source
        +
        T6 - the value type of the sixth source
        +
        T7 - the value type of the seventh source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - a second source ObservableSource
        +
        source3 - a third source ObservableSource
        +
        source4 - a fourth source ObservableSource
        +
        source5 - a fifth source ObservableSource
        +
        source6 - a sixth source ObservableSource
        +
        source7 - a seventh source ObservableSource
        +
        zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in + an item that will be emitted by the resulting Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6, + source7 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T1,T2,T3,T4,T5,T6,T7,T8,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull ObservableSource<? extends T3> source3,
+        @NonNull ObservableSource<? extends T4> source4,
+        @NonNull ObservableSource<? extends T5> source5,
+        @NonNull ObservableSource<? extends T6> source6,
+        @NonNull ObservableSource<? extends T7> source7,
+        @NonNull ObservableSource<? extends T8> source8,
+        @NonNull Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)
        +
        Returns an Observable that emits the results of a specified combiner function applied to combinations of + eight items emitted, in sequence, by eight other ObservableSources. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the resulting Observable + will be the result of the function applied to the first item emitted by each source ObservableSource, the + second item emitted by the resulting Observable will be the result of the function applied to the second item + emitted by each of those ObservableSources, and so forth. +

        + The resulting Observable<R> returned from zip will invoke onNext + as many times as the number of onNext invocations of the ObservableSource that emits the fewest + items. +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f, g, h) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        T5 - the value type of the fifth source
        +
        T6 - the value type of the sixth source
        +
        T7 - the value type of the seventh source
        +
        T8 - the value type of the eighth source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - a second source ObservableSource
        +
        source3 - a third source ObservableSource
        +
        source4 - a fourth source ObservableSource
        +
        source5 - a fifth source ObservableSource
        +
        source6 - a sixth source ObservableSource
        +
        source7 - a seventh source ObservableSource
        +
        source8 - an eighth source ObservableSource
        +
        zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in + an item that will be emitted by the resulting Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6, + source7, source8 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
+        @NonNull ObservableSource<? extends T2> source2,
+        @NonNull ObservableSource<? extends T3> source3,
+        @NonNull ObservableSource<? extends T4> source4,
+        @NonNull ObservableSource<? extends T5> source5,
+        @NonNull ObservableSource<? extends T6> source6,
+        @NonNull ObservableSource<? extends T7> source7,
+        @NonNull ObservableSource<? extends T8> source8,
+        @NonNull ObservableSource<? extends T9> source9,
+        @NonNull Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)
        +
        Returns an Observable that emits the results of a specified combiner function applied to combinations of + nine items emitted, in sequence, by nine other ObservableSources. +

        + +

        + zip applies this function in strict sequence, so the first item emitted by the resulting Observable + will be the result of the function applied to the first item emitted by each source ObservableSource, the + second item emitted by the resulting Observable will be the result of the function applied to the second item + emitted by each of those ObservableSources, and so forth. +

        + The resulting Observable<R> returned from zip will invoke onNext + as many times as the number of onNext invocations of the ObservableSource that emits the fewest + items. +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f, g, h, i) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +
        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the value type of the first source
        +
        T2 - the value type of the second source
        +
        T3 - the value type of the third source
        +
        T4 - the value type of the fourth source
        +
        T5 - the value type of the fifth source
        +
        T6 - the value type of the sixth source
        +
        T7 - the value type of the seventh source
        +
        T8 - the value type of the eighth source
        +
        T9 - the value type of the ninth source
        +
        R - the zipped result type
        +
        Parameters:
        +
        source1 - the first source ObservableSource
        +
        source2 - a second source ObservableSource
        +
        source3 - a third source ObservableSource
        +
        source4 - a fourth source ObservableSource
        +
        source5 - a fifth source ObservableSource
        +
        source6 - a sixth source ObservableSource
        +
        source7 - a seventh source ObservableSource
        +
        source8 - an eighth source ObservableSource
        +
        source9 - a ninth source ObservableSource
        +
        zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in + an item that will be emitted by the resulting Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4, source5, source6, + source7, source8, source9 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zipArray

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+ @NonNull
+public static <T,R> @NonNull Observable<R> zipArray(@NonNull Function<? super Object[],? extends R> zipper,
+        boolean delayError,
+        int bufferSize,
+        @NonNull ObservableSource<? extends T>... sources)
        +
        Returns an Observable that emits the results of a specified combiner function applied to combinations of + items emitted, in sequence, by an array of other ObservableSources. +

        + zip applies this function in strict sequence, so the first item emitted by the resulting Observable + will be the result of the function applied to the first item emitted by each of the ObservableSources; + the second item emitted by the resulting Observable will be the result of the function applied to the second + item emitted by each of those ObservableSources; and so forth. +

        + The resulting Observable<R> returned from zip will invoke onNext as many times as + the number of onNext invocations of the ObservableSource that emits the fewest items. +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        zip(new ObservableSource[]{range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)}, (a) ->
+ a)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. + +

        + +

        +
        Scheduler:
        +
        zipArray does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element type
        +
        R - the result type
        +
        Parameters:
        +
        sources - an array of source ObservableSources
        +
        zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in + an item that will be emitted by the resulting Observable
        +
        delayError - delay errors signaled by any of the ObservableSource until all ObservableSources terminate
        +
        bufferSize - the number of elements expected from each source ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sources or zipper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + + + + + +
        +
      • +

        ambWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> ambWith(@NonNull ObservableSource<? extends T> other)
        +
        Mirrors the current Observable or the other ObservableSource provided of which the first either emits an item or sends a termination + notification. +

        + +

        + When the current Observable signals an item or terminates first, the subscription to the other + ObservableSource is disposed. If the other ObservableSource signals an item or terminates first, + the subscription to the current Observable is disposed. +

        +
        Scheduler:
        +
        ambWith does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        + If the losing ObservableSource signals an error, the error is routed to the global + error handler via RxJavaPlugins.onError(Throwable). +
        +
        +
        +
        Parameters:
        +
        other - an ObservableSource competing to react first. A subscription to this provided source will occur after + subscribing to the current source.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if other is null
        +
        See Also:
        +
        ReactiveX operators documentation: Amb
        +
        +
        • +
      + + + + + + + + + + + + + +
        +
      • +

        blockingFirst

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final T blockingFirst(@NonNull T defaultItem)
        +
        Returns the first item emitted by the current Observable, or a default value if it emits no + items. +

        + +

        +
        Scheduler:
        +
        blockingFirst does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the source signals an error, the operator wraps a checked Exception + into RuntimeException and throws that. Otherwise, RuntimeExceptions and + Errors are rethrown as they are.
        +
        +
        +
        Parameters:
        +
        defaultItem - a default value to return if the current Observable emits no items
        +
        Returns:
        +
        the first item emitted by the current Observable, or the default value if it emits no + items
        +
        Throws:
        +
        NullPointerException - if defaultItem is null
        +
        See Also:
        +
        ReactiveX documentation: First
        +
        +
        • +
      + + + +
        +
      • +

        blockingForEach

        +
        @SchedulerSupport(value="none")
+public final void blockingForEach(@NonNull Consumer<? super T> onNext)
        +
        Consumes the current Observable in a blocking fashion and invokes the given + Consumer with each upstream item on the current thread until the + upstream terminates. +

        + +

        + Note: the method will only return if the upstream terminates or the current + thread is interrupted. +

        + This method executes the Consumer on the current thread while + subscribe(Consumer) executes the consumer on the original caller thread of the + sequence. +

        +
        Scheduler:
        +
        blockingForEach does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the source signals an error, the operator wraps a checked Exception + into RuntimeException and throws that. Otherwise, RuntimeExceptions and + Errors are rethrown as they are.
        +
        +
        +
        Parameters:
        +
        onNext - the Consumer to invoke for each item emitted by the Observable
        +
        Throws:
        +
        NullPointerException - if onNext is null
        +
        RuntimeException - if an error occurs
        +
        See Also:
        +
        ReactiveX documentation: Subscribe, +subscribe(Consumer), +blockingForEach(Consumer, int)
        +
        +
        • +
      + + + +
        +
      • +

        blockingForEach

        +
        @SchedulerSupport(value="none")
+public final void blockingForEach(@NonNull Consumer<? super T> onNext,
+        int capacityHint)
        +
        Consumes the current Observable in a blocking fashion and invokes the given + Consumer with each upstream item on the current thread until the + upstream terminates. +

        + +

        + Note: the method will only return if the upstream terminates or the current + thread is interrupted. +

        + This method executes the Consumer on the current thread while + subscribe(Consumer) executes the consumer on the original caller thread of the + sequence. +

        +
        Scheduler:
        +
        blockingForEach does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the source signals an error, the operator wraps a checked Exception + into RuntimeException and throws that. Otherwise, RuntimeExceptions and + Errors are rethrown as they are.
        +
        +
        +
        Parameters:
        +
        onNext - the Consumer to invoke for each item emitted by the Observable
        +
        capacityHint - the number of items expected to be buffered (allows reducing buffer reallocations)
        +
        Throws:
        +
        NullPointerException - if onNext is null
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        RuntimeException - if an error occurs; Errors and RuntimeExceptions are rethrown + as they are, checked Exceptions are wrapped into RuntimeExceptions
        +
        See Also:
        +
        ReactiveX documentation: Subscribe, +subscribe(Consumer)
        +
        +
        • +
      + + + + + + + + + + + + + + + + + +
        +
      • +

        blockingLast

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final T blockingLast(@NonNull T defaultItem)
        +
        Returns the last item emitted by the current Observable, or a default value if it emits no + items. +

        + +

        +
        Scheduler:
        +
        blockingLast does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the source signals an error, the operator wraps a checked Exception + into RuntimeException and throws that. Otherwise, RuntimeExceptions and + Errors are rethrown as they are.
        +
        +
        +
        Parameters:
        +
        defaultItem - a default value to return if the current Observable emits no items
        +
        Returns:
        +
        the last item emitted by the Observable, or the default value if it emits no + items
        +
        Throws:
        +
        NullPointerException - if defaultItem is null
        +
        See Also:
        +
        ReactiveX documentation: Last
        +
        +
        • +
      + + + +
        +
      • +

        blockingLatest

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Iterable<T> blockingLatest()
        +
        Returns an Iterable that returns the latest item emitted by the current Observable, + waiting if necessary for one to become available. +

        + +

        + If the current Observable produces items faster than Iterator.next takes them, + onNext events might be skipped, but onError or onComplete events are not. +

        + Note also that an onNext directly followed by onComplete might hide the onNext + event. +

        +
        Scheduler:
        +
        blockingLatest does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Iterable instance
        +
        See Also:
        +
        ReactiveX documentation: First
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        blockingSingle

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final T blockingSingle(@NonNull T defaultItem)
        +
        If the current Observable completes after emitting a single item, return that item; if it emits + more than one item, throw an IllegalArgumentException; if it emits no items, return a default + value. +

        + +

        +
        Scheduler:
        +
        blockingSingle does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the source signals an error, the operator wraps a checked Exception + into RuntimeException and throws that. Otherwise, RuntimeExceptions and + Errors are rethrown as they are.
        +
        +
        +
        Parameters:
        +
        defaultItem - a default value to return if the current Observable emits no items
        +
        Returns:
        +
        the single item emitted by the current Observable, or the default value if it emits no + items
        +
        Throws:
        +
        NullPointerException - if defaultItem is null
        +
        See Also:
        +
        ReactiveX documentation: First
        +
        +
        • +
      + + + + + + + +
        +
      • +

        blockingSubscribe

        +
        @SchedulerSupport(value="none")
+public final void blockingSubscribe()
        +
        Runs the current Observable to a terminal event, ignoring any values and rethrowing any exception. +

        + +

        + Note that calling this method will block the caller thread until the upstream terminates + normally or with an error. Therefore, calling this method from special threads such as the + Android Main Thread or the Swing Event Dispatch Thread is not recommended. +

        +
        Scheduler:
        +
        blockingSubscribe does not operate by default on a particular Scheduler.
        +
        +
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        blockingSubscribe(Consumer), +blockingSubscribe(Consumer, Consumer), +blockingSubscribe(Consumer, Consumer, Action)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        blockingSubscribe

        +
        @SchedulerSupport(value="none")
+public final void blockingSubscribe(@NonNull Consumer<? super T> onNext,
+        @NonNull Consumer<? super Throwable> onError)
        +
        Subscribes to the source and calls the given callbacks on the current thread. +

        + +

        + Note that calling this method will block the caller thread until the upstream terminates + normally or with an error. Therefore, calling this method from special threads such as the + Android Main Thread or the Swing Event Dispatch Thread is not recommended. +

        +
        Scheduler:
        +
        blockingSubscribe does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        onNext - the callback action for each source value
        +
        onError - the callback action for an error event
        +
        Throws:
        +
        NullPointerException - if onNext or onError is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        blockingSubscribe(Consumer, Consumer, Action)
        +
        +
        • +
      + + + +
        +
      • +

        blockingSubscribe

        +
        @SchedulerSupport(value="none")
+public final void blockingSubscribe(@NonNull Consumer<? super T> onNext,
+        @NonNull Consumer<? super Throwable> onError,
+        @NonNull Action onComplete)
        +
        Subscribes to the source and calls the given callbacks on the current thread. +

        + +

        + Note that calling this method will block the caller thread until the upstream terminates + normally or with an error. Therefore, calling this method from special threads such as the + Android Main Thread or the Swing Event Dispatch Thread is not recommended. +

        +
        Scheduler:
        +
        blockingSubscribe does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        onNext - the callback action for each source value
        +
        onError - the callback action for an error event
        +
        onComplete - the callback action for the completion event.
        +
        Throws:
        +
        NullPointerException - if onNext, onError or onComplete is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        blockingSubscribe

        +
        @SchedulerSupport(value="none")
+public final void blockingSubscribe(@NonNull Observer<? super T> observer)
        +
        Subscribes to the source and calls the Observer methods on the current thread. +

        + Note that calling this method will block the caller thread until the upstream terminates + normally, with an error or the Observer disposes the Disposable it receives via + Observer.onSubscribe(Disposable). + Therefore, calling this method from special threads such as the + Android Main Thread or the Swing Event Dispatch Thread is not recommended. +

        +
        Scheduler:
        +
        blockingSubscribe does not operate by default on a particular Scheduler.
        +
        + The a dispose() call is composed through.
        +
        +
        Parameters:
        +
        observer - the Observer instance to forward events and calls to in the current thread
        +
        Throws:
        +
        NullPointerException - if observer is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<List<T>> buffer(int count)
        +
        Returns an Observable that emits buffers of items it collects from the current Observable. The resulting + Observable emits connected, non-overlapping buffers, each containing count items. When the current + Observable completes, the resulting Observable emits the current buffer and propagates the notification + from the current Observable. Note that if the current Observable issues an onError notification + the event is passed on immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - the maximum number of items in each buffer before it should be emitted
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<List<T>> buffer(int count,
+        int skip)
        +
        Returns an Observable that emits buffers of items it collects from the current Observable. The resulting + Observable emits buffers every skip items, each containing count items. When the current + Observable completes, the resulting Observable emits the current buffer and propagates the notification + from the current Observable. Note that if the current Observable issues an onError notification + the event is passed on immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - the maximum size of each buffer before it should be emitted
        +
        skip - how many items emitted by the current Observable should be skipped before starting a new + buffer. Note that when skip and count are equal, this is the same operation as + buffer(int).
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        IllegalArgumentException - if count or skip is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U extends Collection<? super T>> @NonNull Observable<U> buffer(int count,
+        int skip,
+        @NonNull Supplier<U> bufferSupplier)
        +
        Returns an Observable that emits buffers of items it collects from the current Observable. The resulting + Observable emits buffers every skip items, each containing count items. When the current + Observable completes, the resulting Observable emits the current buffer and propagates the notification + from the current Observable. Note that if the current Observable issues an onError notification + the event is passed on immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the collection subclass type to buffer into
        +
        Parameters:
        +
        count - the maximum size of each buffer before it should be emitted
        +
        skip - how many items emitted by the current Observable should be skipped before starting a new + buffer. Note that when skip and count are equal, this is the same operation as + buffer(int).
        +
        bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned + as the buffer
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if bufferSupplier is null
        +
        IllegalArgumentException - if count or skip is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U extends Collection<? super T>> @NonNull Observable<U> buffer(int count,
+        @NonNull Supplier<U> bufferSupplier)
        +
        Returns an Observable that emits buffers of items it collects from the current Observable. The resulting + Observable emits connected, non-overlapping buffers, each containing count items. When the current + Observable completes, the resulting Observable emits the current buffer and propagates the notification + from the current Observable. Note that if the current Observable issues an onError notification + the event is passed on immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the collection subclass type to buffer into
        +
        Parameters:
        +
        count - the maximum number of items in each buffer before it should be emitted
        +
        bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned + as the buffer
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if bufferSupplier is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Observable<List<T>> buffer(long timespan,
+        long timeskip,
+        @NonNull TimeUnit unit)
        +
        Returns an Observable that emits buffers of items it collects from the current Observable. The resulting + Observable starts a new buffer periodically, as determined by the timeskip argument. It emits + each buffer after a fixed timespan, specified by the timespan argument. When the current + Observable completes, the resulting Observable emits the current buffer and propagates the notification + from the current Observable. Note that if the current Observable issues an onError notification + the event is passed on immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Scheduler:
        +
        This version of buffer operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted
        +
        timeskip - the period of time after which a new buffer will be created
        +
        unit - the unit of time that applies to the timespan and timeskip arguments
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<List<T>> buffer(long timespan,
+        long timeskip,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns an Observable that emits buffers of items it collects from the current Observable. The resulting + Observable starts a new buffer periodically, as determined by the timeskip argument, and on the + specified scheduler. It emits each buffer after a fixed timespan, specified by the + timespan argument. When the current Observable completes, the resulting Observable emits the + current buffer and propagates the notification from the current Observable. Note that if the current + Observable issues an onError notification the event is passed on immediately without first emitting the + buffer it is in the process of assembling. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted
        +
        timeskip - the period of time after which a new buffer will be created
        +
        unit - the unit of time that applies to the timespan and timeskip arguments
        +
        scheduler - the Scheduler to use when determining the end and start of a buffer
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final <U extends Collection<? super T>> @NonNull Observable<U> buffer(long timespan,
+        long timeskip,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        @NonNull Supplier<U> bufferSupplier)
        +
        Returns an Observable that emits buffers of items it collects from the current Observable. The resulting + Observable starts a new buffer periodically, as determined by the timeskip argument, and on the + specified scheduler. It emits each buffer after a fixed timespan, specified by the + timespan argument. When the current Observable completes, the resulting Observable emits the + current buffer and propagates the notification from the current Observable. Note that if the current + Observable issues an onError notification the event is passed on immediately without first emitting the + buffer it is in the process of assembling. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Type Parameters:
        +
        U - the collection subclass type to buffer into
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted
        +
        timeskip - the period of time after which a new buffer will be created
        +
        unit - the unit of time that applies to the timespan and timeskip arguments
        +
        scheduler - the Scheduler to use when determining the end and start of a buffer
        +
        bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned + as the buffer
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit, scheduler or bufferSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Observable<List<T>> buffer(long timespan,
+        @NonNull TimeUnit unit)
        +
        Returns an Observable that emits buffers of items it collects from the current Observable. The resulting + Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the + timespan argument. When the current Observable completes, the resulting Observable emits the + current buffer and propagates the notification from the current Observable. Note that if the current + Observable issues an onError notification the event is passed on immediately without first emitting the + buffer it is in the process of assembling. +

        + +

        +
        Scheduler:
        +
        This version of buffer operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted and replaced with a new + buffer
        +
        unit - the unit of time that applies to the timespan argument
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Observable<List<T>> buffer(long timespan,
+        @NonNull TimeUnit unit,
+        int count)
        +
        Returns an Observable that emits buffers of items it collects from the current Observable. The resulting + Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the + timespan argument or a maximum size specified by the count argument (whichever is reached + first). When the current Observable completes, the resulting Observable emits the current buffer and + propagates the notification from the current Observable. Note that if the current Observable issues an + onError notification the event is passed on immediately without first emitting the buffer it is in the process of + assembling. +

        + +

        +
        Scheduler:
        +
        This version of buffer operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted and replaced with a new + buffer
        +
        unit - the unit of time which applies to the timespan argument
        +
        count - the maximum size of each buffer before it is emitted
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<List<T>> buffer(long timespan,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        int count)
        +
        Returns an Observable that emits buffers of items it collects from the current Observable. The resulting + Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the + timespan argument as measured on the specified scheduler, or a maximum size specified by + the count argument (whichever is reached first). When the current Observable completes, the resulting + Observable emits the current buffer and propagates the notification from the current Observable. Note + that if the current Observable issues an onError notification the event is passed on immediately without + first emitting the buffer it is in the process of assembling. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted and replaced with a new + buffer
        +
        unit - the unit of time which applies to the timespan argument
        +
        scheduler - the Scheduler to use when determining the end and start of a buffer
        +
        count - the maximum size of each buffer before it is emitted
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final <U extends Collection<? super T>> @NonNull Observable<U> buffer(long timespan,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        int count,
+        @NonNull Supplier<U> bufferSupplier,
+        boolean restartTimerOnMaxSize)
        +
        Returns an Observable that emits buffers of items it collects from the current Observable. The resulting + Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the + timespan argument as measured on the specified scheduler, or a maximum size specified by + the count argument (whichever is reached first). When the current Observable completes, the resulting + Observable emits the current buffer and propagates the notification from the current Observable. Note + that if the current Observable issues an onError notification the event is passed on immediately without + first emitting the buffer it is in the process of assembling. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Type Parameters:
        +
        U - the collection subclass type to buffer into
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted and replaced with a new + buffer
        +
        unit - the unit of time which applies to the timespan argument
        +
        scheduler - the Scheduler to use when determining the end and start of a buffer
        +
        count - the maximum size of each buffer before it is emitted
        +
        bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned + as the buffer
        +
        restartTimerOnMaxSize - if true, the time window is restarted when the max capacity of the current buffer + is reached
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit, scheduler or bufferSupplier is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<List<T>> buffer(long timespan,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns an Observable that emits buffers of items it collects from the current Observable. The resulting + Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the + timespan argument and on the specified scheduler. When the current Observable completes, + the resulting Observable emits the current buffer and propagates the notification from the current + Observable. Note that if the current Observable issues an onError notification the event is passed on + immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each buffer collects items before it is emitted and replaced with a new + buffer
        +
        unit - the unit of time which applies to the timespan argument
        +
        scheduler - the Scheduler to use when determining the end and start of a buffer
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <TOpening,TClosing> @NonNull Observable<List<T>> buffer(@NonNull ObservableSource<? extends TOpening> openingIndicator,
+        @NonNull Function<? super TOpening,? extends ObservableSource<? extends TClosing>> closingIndicator)
        +
        Returns an Observable that emits buffers of items it collects from the current Observable. The resulting + Observable emits buffers that it creates when the specified openingIndicator ObservableSource emits an + item, and closes when the ObservableSource returned from closingIndicator emits an item. If any of the + current Observable, openingIndicator or closingIndicator issues an onError notification the + event is passed on immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        TOpening - the element type of the buffer-opening ObservableSource
        +
        TClosing - the element type of the individual buffer-closing ObservableSources
        +
        Parameters:
        +
        openingIndicator - the ObservableSource that, when it emits an item, causes a new buffer to be created
        +
        closingIndicator - the Function that is used to produce an ObservableSource for every buffer created. When this indicator + ObservableSource emits an item, the associated buffer is emitted.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if openingIndicator or closingIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <TOpening,TClosing,U extends Collection<? super T>> @NonNull Observable<U> buffer(@NonNull ObservableSource<? extends TOpening> openingIndicator,
+        @NonNull Function<? super TOpening,? extends ObservableSource<? extends TClosing>> closingIndicator,
+        @NonNull Supplier<U> bufferSupplier)
        +
        Returns an Observable that emits buffers of items it collects from the current Observable. The resulting + Observable emits buffers that it creates when the specified openingIndicator ObservableSource emits an + item, and closes when the ObservableSource returned from closingIndicator emits an item. If any of the + current Observable, openingIndicator or closingIndicator issues an onError notification the + event is passed on immediately without first emitting the buffer it is in the process of assembling. +

        + +

        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the collection subclass type to buffer into
        +
        TOpening - the element type of the buffer-opening ObservableSource
        +
        TClosing - the element type of the individual buffer-closing ObservableSources
        +
        Parameters:
        +
        openingIndicator - the ObservableSource that, when it emits an item, causes a new buffer to be created
        +
        closingIndicator - the Function that is used to produce an ObservableSource for every buffer created. When this indicator + ObservableSource emits an item, the associated buffer is emitted.
        +
        bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned + as the buffer
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if openingIndicator, closingIndicator or bufferSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <B> @NonNull Observable<List<T>> buffer(@NonNull ObservableSource<B> boundaryIndicator)
        +
        Returns an Observable that emits non-overlapping buffered items from the current Observable each time the + specified boundary ObservableSource emits an item. +

        + +

        + Completion of either the source or the boundary ObservableSource causes the returned ObservableSource to emit the + latest buffer and complete. If either the current Observable or the boundary ObservableSource issues an + onError notification the event is passed on immediately without first emitting the buffer it is in the process of + assembling. +

        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        B - the boundary value type (ignored)
        +
        Parameters:
        +
        boundaryIndicator - the boundary ObservableSource
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if boundaryIndicator is null
        +
        See Also:
        +
        buffer(ObservableSource, int), +ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <B> @NonNull Observable<List<T>> buffer(@NonNull ObservableSource<B> boundaryIndicator,
+        int initialCapacity)
        +
        Returns an Observable that emits non-overlapping buffered items from the current Observable each time the + specified boundary ObservableSource emits an item. +

        + +

        + Completion of either the source or the boundary ObservableSource causes the returned ObservableSource to emit the + latest buffer and complete. If either the current Observable or the boundary ObservableSource issues an + onError notification the event is passed on immediately without first emitting the buffer it is in the process of + assembling. +

        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        B - the boundary value type (ignored)
        +
        Parameters:
        +
        boundaryIndicator - the boundary ObservableSource
        +
        initialCapacity - the initial capacity of each buffer chunk
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if boundaryIndicator is null
        +
        IllegalArgumentException - if initialCapacity is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Buffer, +buffer(ObservableSource)
        +
        +
        • +
      + + + +
        +
      • +

        buffer

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <B,U extends Collection<? super T>> @NonNull Observable<U> buffer(@NonNull ObservableSource<B> boundaryIndicator,
+        @NonNull Supplier<U> bufferSupplier)
        +
        Returns an Observable that emits non-overlapping buffered items from the current Observable each time the + specified boundary ObservableSource emits an item. +

        + +

        + Completion of either the source or the boundary ObservableSource causes the returned ObservableSource to emit the + latest buffer and complete. If either the current Observable or the boundary ObservableSource issues an + onError notification the event is passed on immediately without first emitting the buffer it is in the process of + assembling. +

        +
        Scheduler:
        +
        This version of buffer does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the collection subclass type to buffer into
        +
        B - the boundary value type (ignored)
        +
        Parameters:
        +
        boundaryIndicator - the boundary ObservableSource
        +
        bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned + as the buffer
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if boundaryIndicator or bufferSupplier is null
        +
        See Also:
        +
        buffer(ObservableSource, int), +ReactiveX operators documentation: Buffer
        +
        +
        • +
      + + + +
        +
      • +

        cache

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> cache()
        +
        Returns an Observable that subscribes to the current Observable lazily, caches all of its events + and replays them, in the same order as received, to all the downstream observers. +

        + +

        + This is useful when you want an Observable to cache responses and you can't control the + subscribe/dispose behavior of all the Observers. +

        + The operator subscribes only when the first downstream observer subscribes and maintains + a single subscription towards the current Observable. In contrast, the operator family of replay() + that return a ConnectableObservable require an explicit call to ConnectableObservable.connect(). +

        + Note: You sacrifice the ability to dispose the origin when you use the cache + operator so be careful not to use this operator on Observables that emit an infinite or very large number + of items that will use up memory. + A possible workaround is to apply takeUntil with a predicate or + another source before (and perhaps after) the application of cache(). + 

        
+ AtomicBoolean shouldStop = new AtomicBoolean();
+
+ source.takeUntil(v -> shouldStop.get())
+       .cache()
+       .takeUntil(v -> shouldStop.get())
+       .subscribe(...);
+
        + Since the operator doesn't allow clearing the cached values either, the possible workaround is + to forget all references to it via onTerminateDetach() applied along with the previous + workaround: + 
        
+ AtomicBoolean shouldStop = new AtomicBoolean();
+
+ source.takeUntil(v -> shouldStop.get())
+       .onTerminateDetach()
+       .cache()
+       .takeUntil(v -> shouldStop.get())
+       .onTerminateDetach()
+       .subscribe(...);
+
        +
        +
        Scheduler:
        +
        cache does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Observable instance
        +
        See Also:
        +
        ReactiveX operators documentation: Replay, +takeUntil(Predicate), +takeUntil(ObservableSource)
        +
        +
        • +
      + + + +
        +
      • +

        cacheWithInitialCapacity

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> cacheWithInitialCapacity(int initialCapacity)
        +
        Returns an Observable that subscribes to the current Observable lazily, caches all of its events + and replays them, in the same order as received, to all the downstream observers. +

        + +

        + This is useful when you want an Observable to cache responses and you can't control the + subscribe/dispose behavior of all the Observers. +

        + The operator subscribes only when the first downstream observer subscribes and maintains + a single subscription towards the current Observable. In contrast, the operator family of replay() + that return a ConnectableObservable require an explicit call to ConnectableObservable.connect(). +

        + Note: You sacrifice the ability to dispose the origin when you use the cache + operator so be careful not to use this operator on Observables that emit an infinite or very large number + of items that will use up memory. + A possible workaround is to apply `takeUntil` with a predicate or + another source before (and perhaps after) the application of cache(). + 

        
+ AtomicBoolean shouldStop = new AtomicBoolean();
+
+ source.takeUntil(v -> shouldStop.get())
+       .cache()
+       .takeUntil(v -> shouldStop.get())
+       .subscribe(...);
+
        + Since the operator doesn't allow clearing the cached values either, the possible workaround is + to forget all references to it via onTerminateDetach() applied along with the previous + workaround: + 
        
+ AtomicBoolean shouldStop = new AtomicBoolean();
+
+ source.takeUntil(v -> shouldStop.get())
+       .onTerminateDetach()
+       .cache()
+       .takeUntil(v -> shouldStop.get())
+       .onTerminateDetach()
+       .subscribe(...);
+
        +
        +
        Scheduler:
        +
        cacheWithInitialCapacity does not operate by default on a particular Scheduler.
        +
        +

        + Note: The capacity hint is not an upper bound on cache size. For that, consider + replay(int) in combination with ConnectableObservable.autoConnect() or similar.

        +
        +
        Parameters:
        +
        initialCapacity - hint for number of items to cache (for optimizing underlying data structure)
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        IllegalArgumentException - if initialCapacity is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay, +takeUntil(Predicate), +takeUntil(ObservableSource)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        collect

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U> @NonNull Single<U> collect(@NonNull Supplier<? extends U> initialItemSupplier,
+        @NonNull BiConsumer<? super U,? super T> collector)
        +
        Collects items emitted by the finite source Observable into a single mutable data structure and returns + a Single that emits this structure. +

        + +

        + This is a simplified version of reduce that does not need to return the state on each pass. +

        + Note that this operator requires the upstream to signal onComplete for the accumulator object to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        collect does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the accumulator and output type
        +
        Parameters:
        +
        initialItemSupplier - the mutable data structure that will collect the items
        +
        collector - a function that accepts the state and an emitted item, and modifies the accumulator accordingly + accordingly
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if initialItemSupplier or collector is null
        +
        See Also:
        +
        ReactiveX operators documentation: Reduce
        +
        +
        • +
      + + + + + +
        +
      • +

        collectInto

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U> @NonNull Single<U> collectInto(@NonNull U initialItem,
+        @NonNull BiConsumer<? super U,? super T> collector)
        +
        Collects items emitted by the finite source Observable into a single mutable data structure and returns + a Single that emits this structure. +

        + +

        + This is a simplified version of reduce that does not need to return the state on each pass. +

        + Note that this operator requires the upstream to signal onComplete for the accumulator object to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        collectInto does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the accumulator and output type
        +
        Parameters:
        +
        initialItem - the mutable data structure that will collect the items
        +
        collector - a function that accepts the state and an emitted item, and modifies the accumulator accordingly + accordingly
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if initialItem or collector is null
        +
        See Also:
        +
        ReactiveX operators documentation: Reduce
        +
        +
        • +
      + + + + + + + +
        +
      • +

        concatMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper)
        +
        Returns a new Observable that emits items resulting from applying a function that you supply to each item + emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items + that result from concatenating those returned ObservableSources. +

        + +

        + Note that there is no guarantee where the given mapper function will be executed; it could be on the subscribing thread, + on the upstream thread signaling the new item to be mapped or on the thread where the inner source terminates. To ensure + the mapper function is confined to a known thread, use the concatMap(Function, int, Scheduler) overload. +

        +
        Scheduler:
        +
        concatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of the inner ObservableSource sources and thus the output type
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Observable, returns an + ObservableSource
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap, +concatMap(Function, int, Scheduler)
        +
        +
        • +
      + + + +
        +
      • +

        concatMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
+        int bufferSize)
        +
        Returns a new Observable that emits items resulting from applying a function that you supply to each item + emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items + that result from concatenating those returned ObservableSources. +

        + +

        + Note that there is no guarantee where the given mapper function will be executed; it could be on the subscribing thread, + on the upstream thread signaling the new item to be mapped or on the thread where the inner source terminates. To ensure + the mapper function is confined to a known thread, use the concatMap(Function, int, Scheduler) overload. +

        +
        Scheduler:
        +
        concatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of the inner ObservableSource sources and thus the output type
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Observable, returns an + ObservableSource
        +
        bufferSize - the number of elements expected from the current Observable to be buffered
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap, +concatMap(Function, int, Scheduler)
        +
        +
        • +
      + + + +
        +
      • +

        concatMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
+        int bufferSize,
+        @NonNull Scheduler scheduler)
        +
        Returns a new Observable that emits items resulting from applying a function that you supply to each item + emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items + that result from concatenating those returned ObservableSources. +

        + +

        + The difference between concatMap(Function, int) and this operator is that this operator guarantees the mapper + function is executed on the specified scheduler. +

        +
        Scheduler:
        +
        concatMap executes the given mapper function on the provided Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of the inner ObservableSource sources and thus the output type
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Observable, returns an + ObservableSource
        +
        bufferSize - the number of elements expected from the current Observable to be buffered
        +
        scheduler - the scheduler where the mapper function will be executed
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper or scheduler is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        concatMapDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper)
        +
        Maps each of the items into an ObservableSource, subscribes to them one after the other, + one at a time and emits their values in order + while delaying any error from either this or any of the inner ObservableSources + till all of them terminate. +

        + +

        + Note that there is no guarantee where the given mapper function will be executed; it could be on the subscribing thread, + on the upstream thread signaling the new item to be mapped or on the thread where the inner source terminates. To ensure + the mapper function is confined to a known thread, use the concatMapDelayError(Function, boolean, int, Scheduler) overload. +

        +
        Scheduler:
        +
        concatMapDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - the function that maps the items of the current Observable into the inner ObservableSources.
        +
        Returns:
        +
        the new Observable instance with the concatenation behavior
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        See Also:
        +
        concatMapDelayError(Function, boolean, int, Scheduler)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
+        boolean tillTheEnd,
+        int bufferSize)
        +
        Maps each of the items into an ObservableSource, subscribes to them one after the other, + one at a time and emits their values in order + while delaying any error from either this or any of the inner ObservableSources + till all of them terminate. +

        + +

        + Note that there is no guarantee where the given mapper function will be executed; it could be on the subscribing thread, + on the upstream thread signaling the new item to be mapped or on the thread where the inner source terminates. To ensure + the mapper function is confined to a known thread, use the concatMapDelayError(Function, boolean, int, Scheduler) overload. +

        +
        Scheduler:
        +
        concatMapDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - the function that maps the items of the current Observable into the inner ObservableSources.
        +
        tillTheEnd - if true, all errors from the outer and inner ObservableSource sources are delayed until the end, + if false, an error from the main source is signaled when the current Observable source terminates
        +
        bufferSize - the number of elements expected from the current Observable to be buffered
        +
        Returns:
        +
        the new Observable instance with the concatenation behavior
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        concatMapDelayError(Function, boolean, int, Scheduler)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
+        boolean tillTheEnd,
+        int bufferSize,
+        @NonNull Scheduler scheduler)
        +
        Maps each of the items into an ObservableSource, subscribes to them one after the other, + one at a time and emits their values in order + while delaying any error from either this or any of the inner ObservableSources + till all of them terminate. +

        + +

        +
        Scheduler:
        +
        concatMapDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - the function that maps the items of the current Observable into the inner ObservableSources.
        +
        tillTheEnd - if true, all errors from the outer and inner ObservableSource sources are delayed until the end, + if false, an error from the main source is signaled when the current Observable source terminates
        +
        bufferSize - the number of elements expected from the current Observable to be buffered
        +
        scheduler - the scheduler where the mapper function will be executed
        +
        Returns:
        +
        the new Observable instance with the concatenation behavior
        +
        Throws:
        +
        NullPointerException - if mapper or scheduler is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        concatMapDelayError(Function, boolean, int)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapEager

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapEager(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper)
        +
        Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single + Observable sequence. +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + current Observables. The operator buffers the values emitted by these ObservableSources and then drains them in + order, each one after the previous one completes. +

        + +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type
        +
        Parameters:
        +
        mapper - the function that maps a sequence of values into a sequence of ObservableSources that will be + eagerly concatenated
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatMapEager

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapEager(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
+        int maxConcurrency,
+        int bufferSize)
        +
        Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single + Observable sequence. +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + current Observables. The operator buffers the values emitted by these ObservableSources and then drains them in + order, each one after the previous one completes. +

        + +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type
        +
        Parameters:
        +
        mapper - the function that maps a sequence of values into a sequence of ObservableSources that will be + eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrent subscribed ObservableSources
        +
        bufferSize - hints about the number of expected items from each inner ObservableSource, must be positive
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatMapEagerDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapEagerDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
+        boolean tillTheEnd)
        +
        Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single + Observable sequence. +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + current Observables. The operator buffers the values emitted by these ObservableSources and then drains them in + order, each one after the previous one completes. +

        + +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type
        +
        Parameters:
        +
        mapper - the function that maps a sequence of values into a sequence of ObservableSources that will be + eagerly concatenated
        +
        tillTheEnd - if true, all errors from the outer and inner ObservableSource sources are delayed until the end, + if false, an error from the main source is signaled when the current Observable source terminates
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        concatMapEagerDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapEagerDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
+        boolean tillTheEnd,
+        int maxConcurrency,
+        int bufferSize)
        +
        Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single + Observable sequence. +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + current Observables. The operator buffers the values emitted by these ObservableSources and then drains them in + order, each one after the previous one completes. +

        + +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type
        +
        Parameters:
        +
        mapper - the function that maps a sequence of values into a sequence of ObservableSources that will be + eagerly concatenated
        +
        tillTheEnd - if true, exceptions from the current Observable and all the inner ObservableSources are delayed until + all of them terminate, if false, exception from the current Observable is delayed until the + currently running ObservableSource terminates
        +
        maxConcurrency - the maximum number of concurrent subscribed ObservableSources
        +
        bufferSize - the number of elements expected from the current Observable and each inner ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + + + +
        +
      • +

        concatMapCompletable

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Completable concatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper,
+        int capacityHint)
        +
        Maps each element of the current Observable into CompletableSources, subscribes to them one at a time in + order and waits until the upstream and all CompletableSources complete. +

        + +

        +
        Scheduler:
        +
        concatMapCompletable does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.6 - experimental

        +
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Observable, returns a CompletableSource
        +
        capacityHint - the number of upstream items expected to be buffered until the current CompletableSource, mapped from + the current item, completes.
        +
        Returns:
        +
        the new Completable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + + + + + +
        +
      • +

        concatMapCompletableDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Completable concatMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper,
+        boolean tillTheEnd)
        +
        Maps the upstream items into CompletableSources and subscribes to them one after the + other terminates, optionally delaying all errors till both the current Observable and all + inner CompletableSources terminate. +

        + +

        +
        Scheduler:
        +
        concatMapCompletableDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a CompletableSource to become the next source to + be subscribed to
        +
        tillTheEnd - If true, errors from the current Observable or any of the + inner CompletableSources are delayed until all + of them terminate. If false, an error from the current + Observable is delayed until the current inner + CompletableSource terminates and only then is + it emitted to the downstream.
        +
        Returns:
        +
        the new Completable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapCompletable(Function)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapCompletableDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Completable concatMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper,
+        boolean tillTheEnd,
+        int bufferSize)
        +
        Maps the upstream items into CompletableSources and subscribes to them one after the + other terminates, optionally delaying all errors till both the current Observable and all + inner CompletableSources terminate. +

        + +

        +
        Scheduler:
        +
        concatMapCompletableDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a CompletableSource to become the next source to + be subscribed to
        +
        tillTheEnd - If true, errors from the current Observable or any of the + inner CompletableSources are delayed until all + of them terminate. If false, an error from the current + Observable is delayed until the current inner + CompletableSource terminates and only then is + it emitted to the downstream.
        +
        bufferSize - The number of upstream items expected to be buffered so that fresh items are + ready to be mapped when a previous CompletableSource terminates.
        +
        Returns:
        +
        the new Completable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapCompletable(Function, int)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapIterable

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U> @NonNull Observable<U> concatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper)
        +
        Returns an Observable that concatenate each item emitted by the current Observable with the values in an + Iterable corresponding to that item that is generated by a selector. +

        + + +

        +
        Scheduler:
        +
        concatMapIterable does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of item emitted by the resulting Observable
        +
        Parameters:
        +
        mapper - a function that returns an Iterable sequence of values for when given an item emitted by the + current Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        concatMapMaybe

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)
        +
        Maps the upstream items into MaybeSources and subscribes to them one after the + other succeeds or completes, emits their success value if available or terminates immediately if + either the current Observable or the current inner MaybeSource fail. +

        + +

        +
        Scheduler:
        +
        concatMapMaybe does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the result type of the inner MaybeSources
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a MaybeSource to become the next source to + be subscribed to
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapMaybeDelayError(Function), +concatMapMaybe(Function, int)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapMaybe

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper,
+        int bufferSize)
        +
        Maps the upstream items into MaybeSources and subscribes to them one after the + other succeeds or completes, emits their success value if available or terminates immediately if + either the current Observable or the current inner MaybeSource fail. +

        + +

        +
        Scheduler:
        +
        concatMapMaybe does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the result type of the inner MaybeSources
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a MaybeSource to become the next source to + be subscribed to
        +
        bufferSize - The number of upstream items expected to be buffered so that fresh items are + ready to be mapped when a previous MaybeSource terminates.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapMaybe(Function), +concatMapMaybeDelayError(Function, boolean, int)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapMaybeDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)
        +
        Maps the upstream items into MaybeSources and subscribes to them one after the + other terminates, emits their success value if available and delaying all errors + till both the current Observable and all inner MaybeSources terminate. +

        + +

        +
        Scheduler:
        +
        concatMapMaybeDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the result type of the inner MaybeSources
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a MaybeSource to become the next source to + be subscribed to
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapMaybe(Function), +concatMapMaybeDelayError(Function, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapMaybeDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper,
+        boolean tillTheEnd)
        +
        Maps the upstream items into MaybeSources and subscribes to them one after the + other terminates, emits their success value if available and optionally delaying all errors + till both the current Observable and all inner MaybeSources terminate. +

        + +

        +
        Scheduler:
        +
        concatMapMaybeDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the result type of the inner MaybeSources
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a MaybeSource to become the next source to + be subscribed to
        +
        tillTheEnd - If true, errors from the current Observable or any of the + inner MaybeSources are delayed until all + of them terminate. If false, an error from the current + Observable is delayed until the current inner + MaybeSource terminates and only then is + it emitted to the downstream.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapMaybe(Function, int), +concatMapMaybeDelayError(Function, boolean, int)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapMaybeDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper,
+        boolean tillTheEnd,
+        int bufferSize)
        +
        Maps the upstream items into MaybeSources and subscribes to them one after the + other terminates, emits their success value if available and optionally delaying all errors + till both the current Observable and all inner MaybeSources terminate. +

        + +

        +
        Scheduler:
        +
        concatMapMaybeDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the result type of the inner MaybeSources
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a MaybeSource to become the next source to + be subscribed to
        +
        tillTheEnd - If true, errors from the current Observable or any of the + inner MaybeSources are delayed until all + of them terminate. If false, an error from the current + Observable is delayed until the current inner + MaybeSource terminates and only then is + it emitted to the downstream.
        +
        bufferSize - The number of upstream items expected to be buffered so that fresh items are + ready to be mapped when a previous MaybeSource terminates.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapMaybe(Function, int)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        concatMapSingle

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper,
+        int bufferSize)
        +
        Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds, emits their success values or terminates immediately if + either the current Observable or the current inner SingleSource fail. +

        + +

        +
        Scheduler:
        +
        concatMapSingle does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the result type of the inner SingleSources
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a SingleSource to become the next source to + be subscribed to
        +
        bufferSize - The number of upstream items expected to be buffered so that fresh items are + ready to be mapped when a previous SingleSource terminates.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapSingle(Function), +concatMapSingleDelayError(Function, boolean, int)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        concatMapSingleDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper,
+        boolean tillTheEnd)
        +
        Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds or fails, emits their success values and optionally delays all errors + till both the current Observable and all inner SingleSources terminate. +

        + +

        +
        Scheduler:
        +
        concatMapSingleDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the result type of the inner SingleSources
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a SingleSource to become the next source to + be subscribed to
        +
        tillTheEnd - If true, errors from the current Observable or any of the + inner SingleSources are delayed until all + of them terminate. If false, an error from the current + Observable is delayed until the current inner + SingleSource terminates and only then is + it emitted to the downstream.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapSingle(Function, int), +concatMapSingleDelayError(Function, boolean, int)
        +
        +
        • +
      + + + +
        +
      • +

        concatMapSingleDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper,
+        boolean tillTheEnd,
+        int bufferSize)
        +
        Maps the upstream items into SingleSources and subscribes to them one after the + other succeeds or fails, emits their success values and optionally delays errors + till both the current Observable and all inner SingleSources terminate. +

        + +

        +
        Scheduler:
        +
        concatMapSingleDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the result type of the inner SingleSources
        +
        Parameters:
        +
        mapper - the function called with the upstream item and should return + a SingleSource to become the next source to + be subscribed to
        +
        tillTheEnd - If true, errors from the current Observable or any of the + inner SingleSources are delayed until all + of them terminate. If false, an error from the current + Observable is delayed until the current inner + SingleSource terminates and only then is + it emitted to the downstream.
        +
        bufferSize - The number of upstream items expected to be buffered so that fresh items are + ready to be mapped when a previous SingleSource terminates.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        concatMapSingle(Function, int)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        concatWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> concatWith(@NonNull SingleSource<? extends T> other)
        +
        Returns an Observable that emits the items from the current Observable followed by the success item or error event + of the other SingleSource. +

        + +

        +
        Scheduler:
        +
        concatWith does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.10 - experimental

        +
        +
        Parameters:
        +
        other - the SingleSource whose signal should be emitted after the current Observable completes normally.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if other is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        concatWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> concatWith(@NonNull MaybeSource<? extends T> other)
        +
        Returns an Observable that emits the items from the current Observable followed by the success item or terminal events + of the other MaybeSource. +

        + +

        +
        Scheduler:
        +
        concatWith does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.10 - experimental

        +
        +
        Parameters:
        +
        other - the MaybeSource whose signal should be emitted after the current Observable completes normally.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if other is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        concatWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> concatWith(@NonNull CompletableSource other)
        +
        Returns an Observable that emits items from the current Observable and when it completes normally, the + other CompletableSource is subscribed to and the returned Observable emits its terminal events. +

        + +

        +
        Scheduler:
        +
        concatWith does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.10 - experimental

        +
        +
        Parameters:
        +
        other - the CompletableSource to subscribe to once the current Observable completes normally
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if other is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        debounce

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U> @NonNull Observable<T> debounce(@NonNull Function<? super T,? extends ObservableSource<U>> debounceIndicator)
        +
        Returns an Observable that mirrors the current Observable, except that it drops items emitted by the + current Observable that are followed by another item within a computed debounce duration + denoted by an item emission or completion from a generated inner ObservableSource for that original item. +

        + +

        + The delivery of the item happens on the thread of the first onNext or onComplete + signal of the generated ObservableSource sequence, + which if takes too long, a newer item may arrive from the upstream, causing the + generated sequence to get disposed, which may also interrupt any downstream blocking operation + (yielding an InterruptedException). It is recommended processing items + that may take long time to be moved to another thread via observeOn(io.reactivex.rxjava3.core.Scheduler) applied after + debounce itself. +

        +
        Scheduler:
        +
        This version of debounce does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the debounce value type (ignored)
        +
        Parameters:
        +
        debounceIndicator - function to return a sequence that indicates the throttle duration for each item via its own emission or completion
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if debounceIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Debounce
        +
        +
        • +
      + + + +
        +
      • +

        debounce

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Observable<T> debounce(long timeout,
+        @NonNull TimeUnit unit)
        +
        Returns an Observable that mirrors the current Observable, except that it drops items emitted by the + current Observable that are followed by newer items before a timeout value expires. The timer resets on + each emission. +

        + Note: If items keep being emitted by the current Observable faster than the timeout then no items + will be emitted by the resulting Observable. +

        + +

        + Delivery of the item after the grace period happens on the computation Scheduler's + Worker which if takes too long, a newer item may arrive from the upstream, causing the + Worker's task to get disposed, which may also interrupt any downstream blocking operation + (yielding an InterruptedException). It is recommended processing items + that may take long time to be moved to another thread via observeOn(io.reactivex.rxjava3.core.Scheduler) applied after + debounce itself. +

        +
        Scheduler:
        +
        debounce operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timeout - the length of the window of time that must pass after the emission of an item from the current + Observable in which the Observable emits no items in order for the item to be emitted by the + resulting Observable
        +
        unit - the unit of time for the specified timeout
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Debounce, +throttleWithTimeout(long, TimeUnit)
        +
        +
        • +
      + + + +
        +
      • +

        debounce

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> debounce(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns an Observable that mirrors the current Observable, except that it drops items emitted by the + current Observable that are followed by newer items before a timeout value expires on a specified + Scheduler. The timer resets on each emission. +

        + Note: If items keep being emitted by the current Observable faster than the timeout then no items + will be emitted by the resulting Observable. +

        + +

        + Delivery of the item after the grace period happens on the given Scheduler's + Worker which if takes too long, a newer item may arrive from the upstream, causing the + Worker's task to get disposed, which may also interrupt any downstream blocking operation + (yielding an InterruptedException). It is recommended processing items + that may take long time to be moved to another thread via observeOn(io.reactivex.rxjava3.core.Scheduler) applied after + debounce itself. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timeout - the time each item has to be "the most recent" of those emitted by the current Observable to + ensure that it's not dropped
        +
        unit - the unit of time for the specified timeout
        +
        scheduler - the Scheduler to use internally to manage the timers that handle the timeout for each + item
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Debounce, +throttleWithTimeout(long, TimeUnit, Scheduler)
        +
        +
        • +
      + + + +
        +
      • +

        debounce

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> debounce(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        @NonNull Consumer<? super T> onDropped)
        +
        Returns an Observable that mirrors the current Observable, except that it drops items emitted by the + current Observable that are followed by newer items before a timeout value expires on a specified + Scheduler. The timer resets on each emission. +

        + Note: If items keep being emitted by the current Observable faster than the timeout then no items + will be emitted by the resulting Observable. +

        + +

        + Delivery of the item after the grace period happens on the given Scheduler's + Worker which if takes too long, a newer item may arrive from the upstream, causing the + Worker's task to get disposed, which may also interrupt any downstream blocking operation + (yielding an InterruptedException). It is recommended processing items + that may take long time to be moved to another thread via observeOn(io.reactivex.rxjava3.core.Scheduler) applied after + debounce itself. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timeout - the time each item has to be "the most recent" of those emitted by the current Observable to + ensure that it's not dropped
        +
        unit - the unit of time for the specified timeout
        +
        scheduler - the Scheduler to use internally to manage the timers that handle the timeout for each + item
        +
        onDropped - called with the current entry when it has been replaced by a new one
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null } or onDropped is null
        +
        Since:
        +
        3.1.6 - Experimental
        +
        See Also:
        +
        ReactiveX operators documentation: Debounce, +throttleWithTimeout(long, TimeUnit, Scheduler, Consumer)
        +
        +
        • +
      + + + + + + + + + +
        +
      • +

        delay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U> @NonNull Observable<T> delay(@NonNull Function<? super T,? extends ObservableSource<U>> itemDelayIndicator)
        +
        Returns an Observable that delays the emissions of the current Observable via + a per-item derived ObservableSource's item emission or termination, on a per source item basis. +

        + +

        + Note: the resulting Observable will immediately propagate any onError notification + from the current Observable. +

        +
        Scheduler:
        +
        This version of delay does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the item delay value type (ignored)
        +
        Parameters:
        +
        itemDelayIndicator - a function that returns an ObservableSource for each item emitted by the current Observable, which is + then used to delay the emission of that item by the resulting Observable until the ObservableSource + returned from itemDelay emits an item
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if itemDelayIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Delay
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        delay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> delay(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean delayError)
        +
        Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a + specified delay. If delayError is true, error notifications will also be delayed. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        time - the delay to shift the source by
        +
        unit - the time unit of delay
        +
        scheduler - the Scheduler to use for delaying
        +
        delayError - if true, the upstream exception is signaled with the given delay, after all preceding normal elements, + if false, the upstream exception is signaled immediately
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Delay
        +
        +
        • +
      + + + +
        +
      • +

        delay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,V> @NonNull Observable<T> delay(@NonNull ObservableSource<U> subscriptionIndicator,
+        @NonNull Function<? super T,? extends ObservableSource<V>> itemDelayIndicator)
        +
        Returns an Observable that delays the subscription to and emissions from the current Observable via + ObservableSources for the subscription itself and on a per-item basis. +

        + +

        + Note: the resulting Observable will immediately propagate any onError notification + from the current Observable. +

        +
        Scheduler:
        +
        This version of delay does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the subscription delay value type (ignored)
        +
        V - the item delay value type (ignored)
        +
        Parameters:
        +
        subscriptionIndicator - a function that returns an ObservableSource that triggers the subscription to the current Observable + once it emits any item
        +
        itemDelayIndicator - a function that returns an ObservableSource for each item emitted by the current Observable, which is + then used to delay the emission of that item by the resulting Observable until the ObservableSource + returned from itemDelay emits an item
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if subscriptionIndicator or itemDelayIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Delay
        +
        +
        • +
      + + + +
        +
      • +

        delaySubscription

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U> @NonNull Observable<T> delaySubscription(@NonNull ObservableSource<U> subscriptionIndicator)
        +
        Returns an Observable that delays the subscription to the current Observable + until the other ObservableSource emits an element or completes normally. +

        + +

        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the value type of the other Observable, irrelevant
        +
        Parameters:
        +
        subscriptionIndicator - the other ObservableSource that should trigger the subscription + to the current Observable.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if subscriptionIndicator is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        dematerialize

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> dematerialize(@NonNull Function<? super T,Notification<R>> selector)
        +
        Returns an Observable that reverses the effect of materialize by transforming the + Notification objects extracted from the source items via a selector function + into their respective Observer signal types. +

        + +

        + The intended use of the selector function is to perform a + type-safe identity mapping (see example) on a source that is already of type + Notification<T>. The Java language doesn't allow + limiting instance methods to a certain generic argument shape, therefore, + a function is used to ensure the conversion remains type safe. +

        + When the upstream signals an onError or + onComplete item, the + returned Observable disposes of the flow and terminates with that type of terminal event: + 

        
+ Observable.just(createOnNext(1), createOnComplete(), createOnNext(2))
+ .doOnDispose(() -> System.out.println("Disposed!"));
+ .dematerialize(notification -> notification)
+ .test()
+ .assertResult(1);
+
        + If the upstream signals onError or onComplete directly, the flow is terminated + with the same event. + 
        
+ Observable.just(createOnNext(1), createOnNext(2))
+ .dematerialize(notification -> notification)
+ .test()
+ .assertResult(1, 2);
+
        + If this behavior is not desired, the completion can be suppressed by applying concatWith(ObservableSource) + with a never() source. +
        +
        Scheduler:
        +
        dematerialize does not operate by default on a particular Scheduler.
        +
        +

        History: 2.2.4 - experimental

        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        selector - function that returns the upstream item and should return a Notification to signal + the corresponding Observer event to the downstream.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if selector is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        ReactiveX operators documentation: Dematerialize
        +
        +
        • +
      + + + + + + + +
        +
      • +

        distinct

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K> @NonNull Observable<T> distinct(@NonNull Function<? super T,K> keySelector)
        +
        Returns an Observable that emits all items emitted by the current Observable that are distinct according + to a key selector function and based on Object.equals(Object) comparison of the objects + returned by the key selector function. +

        + +

        + It is recommended the keys' class K overrides the default Object.equals() + and Object.hashCode() to provide meaningful comparison between the key objects as the default + Java implementation only considers reference equivalence. +

        + By default, distinct() uses an internal HashSet per Observer to remember + previously seen keys and uses Set.add(Object) returning false as the + indicator for duplicates. +

        + Note that this internal HashSet may grow unbounded as keys won't be removed from it by + the operator. Therefore, using very long or infinite upstream (with very distinct keys) may lead + to OutOfMemoryError. +

        + Customizing the retention policy can happen only by providing a custom Collection implementation + to the distinct(Function, Supplier) overload. +

        +
        Scheduler:
        +
        distinct does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        Parameters:
        +
        keySelector - a function that projects an emitted item to a key value that is used to decide whether an item + is distinct from another one or not
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if keySelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: Distinct, +distinct(Function, Supplier)
        +
        +
        • +
      + + + +
        +
      • +

        distinct

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K> @NonNull Observable<T> distinct(@NonNull Function<? super T,K> keySelector,
+        @NonNull Supplier<? extends Collection<? super K>> collectionSupplier)
        +
        Returns an Observable that emits all items emitted by the current Observable that are distinct according + to a key selector function and based on Object.equals(Object) comparison of the objects + returned by the key selector function. +

        + +

        + It is recommended the keys' class K overrides the default Object.equals() + and Object.hashCode() to provide meaningful comparison between the key objects as + the default Java implementation only considers reference equivalence. +

        +
        Scheduler:
        +
        distinct does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        Parameters:
        +
        keySelector - a function that projects an emitted item to a key value that is used to decide whether an item + is distinct from another one or not
        +
        collectionSupplier - function called for each individual Observer to return a Collection subtype for holding the extracted + keys and whose add() method's return indicates uniqueness.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if keySelector or collectionSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: Distinct
        +
        +
        • +
      + + + +
        +
      • +

        distinctUntilChanged

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> distinctUntilChanged()
        +
        Returns an Observable that emits all items emitted by the current Observable that are distinct from their + immediate predecessors based on Object.equals(Object) comparison. +

        + +

        + It is recommended the elements' class T in the flow overrides the default Object.equals() to provide + meaningful comparison between items as the default Java implementation only considers reference equivalence. + Alternatively, use the distinctUntilChanged(BiPredicate) overload and provide a comparison function + in case the class T can't be overridden with custom equals() or the comparison itself + should happen on different terms or properties of the class T. +

        + Note that the operator always retains the latest item from upstream regardless of the comparison result + and uses it in the next comparison with the next upstream item. +

        + Note that if element type T in the flow is mutable, the comparison of the previous and current + item may yield unexpected results if the items are mutated externally. Common cases are mutable + CharSequences or Lists where the objects will actually have the same + references when they are modified and distinctUntilChanged will evaluate subsequent items as same. + To avoid such situation, it is recommended that mutable data is converted to an immutable one, + for example using map(CharSequence::toString) or map(list -> Collections.unmodifiableList(new ArrayList<>(list))). +

        +
        Scheduler:
        +
        distinctUntilChanged does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Observable instance
        +
        See Also:
        +
        ReactiveX operators documentation: Distinct, +distinctUntilChanged(BiPredicate)
        +
        +
        • +
      + + + +
        +
      • +

        distinctUntilChanged

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K> @NonNull Observable<T> distinctUntilChanged(@NonNull Function<? super T,K> keySelector)
        +
        Returns an Observable that emits all items emitted by the current Observable that are distinct from their + immediate predecessors, according to a key selector function and based on Object.equals(Object) comparison + of those objects returned by the key selector function. +

        + +

        + It is recommended the keys' class K overrides the default Object.equals() to provide + meaningful comparison between the key objects as the default Java implementation only considers reference equivalence. + Alternatively, use the distinctUntilChanged(BiPredicate) overload and provide a comparison function + in case the class K can't be overridden with custom equals() or the comparison itself + should happen on different terms or properties of the item class T (for which the keys can be + derived via a similar selector). +

        + Note that the operator always retains the latest key from upstream regardless of the comparison result + and uses it in the next comparison with the next key derived from the next upstream item. +

        + Note that if element type T in the flow is mutable, the comparison of the previous and current + item may yield unexpected results if the items are mutated externally. Common cases are mutable + CharSequences or Lists where the objects will actually have the same + references when they are modified and distinctUntilChanged will evaluate subsequent items as same. + To avoid such situation, it is recommended that mutable data is converted to an immutable one, + for example using map(CharSequence::toString) or map(list -> Collections.unmodifiableList(new ArrayList<>(list))). +

        +
        Scheduler:
        +
        distinctUntilChanged does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        Parameters:
        +
        keySelector - a function that projects an emitted item to a key value that is used to decide whether an item + is distinct from another one or not
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if keySelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: Distinct
        +
        +
        • +
      + + + +
        +
      • +

        distinctUntilChanged

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> distinctUntilChanged(@NonNull BiPredicate<? super T,? super T> comparer)
        +
        Returns an Observable that emits all items emitted by the current Observable that are distinct from their + immediate predecessors when compared with each other via the provided comparator function. +

        + +

        + Note that the operator always retains the latest item from upstream regardless of the comparison result + and uses it in the next comparison with the next upstream item. +

        + Note that if element type T in the flow is mutable, the comparison of the previous and current + item may yield unexpected results if the items are mutated externally. Common cases are mutable + CharSequences or Lists where the objects will actually have the same + references when they are modified and distinctUntilChanged will evaluate subsequent items as same. + To avoid such situation, it is recommended that mutable data is converted to an immutable one, + for example using map(CharSequence::toString) or map(list -> Collections.unmodifiableList(new ArrayList<>(list))). +

        +
        Scheduler:
        +
        distinctUntilChanged does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        comparer - the function that receives the previous item and the current item and is + expected to return true if the two are equal, thus skipping the current value.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if comparer is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: Distinct
        +
        +
        • +
      + + + +
        +
      • +

        doAfterNext

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> doAfterNext(@NonNull Consumer<? super T> onAfterNext)
        +
        Calls the specified Consumer with the current item after this item has been emitted to the downstream. +

        + Note that the onAfterNext action is shared between subscriptions and as such + should be thread-safe. +

        + +

        +
        Scheduler:
        +
        doAfterNext does not operate by default on a particular Scheduler.
        +
        Operator-fusion:
        +
        This operator supports boundary-limited synchronous or asynchronous queue-fusion.
        +
        +

        History: 2.0.1 - experimental

        +
        +
        Parameters:
        +
        onAfterNext - the Consumer that will be called after emitting an item from upstream to the downstream
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if onAfterNext is null
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + + + + + +
        +
      • +

        doFinally

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> doFinally(@NonNull Action onFinally)
        +
        Calls the specified action after the current Observable signals onError or onCompleted or gets disposed by + the downstream. +

        In case of a race between a terminal event and a dispose call, the provided onFinally action + is executed once per subscription. +

        Note that the onFinally action is shared between subscriptions and as such + should be thread-safe. +

        + +

        +
        Scheduler:
        +
        doFinally does not operate by default on a particular Scheduler.
        +
        Operator-fusion:
        +
        This operator supports boundary-limited synchronous or asynchronous queue-fusion.
        +
        +

        History: 2.0.1 - experimental

        +
        +
        Parameters:
        +
        onFinally - the action called when the current Observable terminates or gets disposed
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if onFinally is null
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        doOnEach

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> doOnEach(@NonNull Observer<? super T> observer)
        +
        Returns an Observable that forwards the items and terminal events of the current + Observable to its Observers and to the given shared Observer instance. +

        + In case the onError of the supplied observer throws, the downstream will receive a composite + exception containing the original exception and the exception thrown by onError. If either the + onNext or the onComplete method of the supplied observer throws, the downstream will be + terminated and will receive this thrown exception. +

        + +

        +
        Scheduler:
        +
        doOnEach does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        observer - the observer to be notified about onNext, onError and onComplete events on its + respective methods before the actual downstream Observer gets notified.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if observer is null
        +
        See Also:
        +
        ReactiveX operators documentation: Do
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        doOnSubscribe

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)
        +
        Returns an Observable so that it invokes the given Consumer when the current Observable is subscribed from + its Observers. Each subscription will result in an invocation of the given action except when the + current Observable is reference counted, in which case the current Observable will invoke + the given action for the first subscription. +

        + +

        +
        Scheduler:
        +
        doOnSubscribe does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        onSubscribe - the Consumer that gets called when an Observer subscribes to the current Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if onSubscribe is null
        +
        See Also:
        +
        ReactiveX operators documentation: Do
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper)
        +
        Returns an Observable that emits items based on applying a function that you supply to each item emitted + by the current Observable, where that function returns an ObservableSource, and then merging those returned + ObservableSources and emitting the results of this merger. +

        + +

        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type of the inner ObservableSources and the output type
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Observable, returns an + ObservableSource
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
+        boolean delayErrors)
        +
        Returns an Observable that emits items based on applying a function that you supply to each item emitted + by the current Observable, where that function returns an ObservableSource, and then merging those returned + ObservableSources and emitting the results of this merger. +

        + +

        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type of the inner ObservableSources and the output type
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Observable, returns an + ObservableSource
        +
        delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate + if false, the first one signaling an exception will terminate the whole sequence immediately
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
+        boolean delayErrors,
+        int maxConcurrency)
        +
        Returns an Observable that emits items based on applying a function that you supply to each item emitted + by the current Observable, where that function returns an ObservableSource, and then merging those returned + ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent + subscriptions to these ObservableSources. +

        + +

        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type of the inner ObservableSources and the output type
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Observable, returns an + ObservableSource
        +
        maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently
        +
        delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate + if false, the first one signaling an exception will terminate the whole sequence immediately
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
+        boolean delayErrors,
+        int maxConcurrency,
+        int bufferSize)
        +
        Returns an Observable that emits items based on applying a function that you supply to each item emitted + by the current Observable, where that function returns an ObservableSource, and then merging those returned + ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent + subscriptions to these ObservableSources. +

        + +

        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type of the inner ObservableSources and the output type
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Observable, returns an + ObservableSource
        +
        maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently
        +
        delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate + if false, the first one signaling an exception will terminate the whole sequence immediately
        +
        bufferSize - the number of elements expected from each inner ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> onNextMapper,
+        @NonNull Function<? super Throwable,? extends ObservableSource<? extends R>> onErrorMapper,
+        @NonNull Supplier<? extends ObservableSource<? extends R>> onCompleteSupplier)
        +
        Returns an Observable that applies a function to each item emitted or notification raised by the current + Observable and then flattens the ObservableSources returned from these functions and emits the resulting items. +

        + +

        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result type
        +
        Parameters:
        +
        onNextMapper - a function that returns an ObservableSource to merge for each item emitted by the current Observable
        +
        onErrorMapper - a function that returns an ObservableSource to merge for an onError notification from the current + Observable
        +
        onCompleteSupplier - a function that returns an ObservableSource to merge for an onComplete notification from the current + Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if onNextMapper or onErrorMapper or onCompleteSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> onNextMapper,
+        @NonNull Function<Throwable,? extends ObservableSource<? extends R>> onErrorMapper,
+        @NonNull Supplier<? extends ObservableSource<? extends R>> onCompleteSupplier,
+        int maxConcurrency)
        +
        Returns an Observable that applies a function to each item emitted or notification raised by the current + Observable and then flattens the ObservableSources returned from these functions and emits the resulting items, + while limiting the maximum number of concurrent subscriptions to these ObservableSources. +

        + +

        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result type
        +
        Parameters:
        +
        onNextMapper - a function that returns an ObservableSource to merge for each item emitted by the current Observable
        +
        onErrorMapper - a function that returns an ObservableSource to merge for an onError notification from the current + Observable
        +
        onCompleteSupplier - a function that returns an ObservableSource to merge for an onComplete notification from the current + Observable
        +
        maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if onNextMapper or onErrorMapper or onCompleteSupplier is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
+        int maxConcurrency)
        +
        Returns an Observable that emits items based on applying a function that you supply to each item emitted + by the current Observable, where that function returns an ObservableSource, and then merging those returned + ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent + subscriptions to these ObservableSources. +

        + +

        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the value type of the inner ObservableSources and the output type
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Observable, returns an + ObservableSource
        +
        maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends U>> mapper,
+        @NonNull BiFunction<? super T,? super U,? extends R> combiner)
        +
        Returns an Observable that emits the results of a specified function to the pair of values emitted by the + current Observable and the mapped inner ObservableSource. +

        + +

        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the collection ObservableSource
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        mapper - a function that returns an ObservableSource for each item emitted by the current Observable
        +
        combiner - a function that combines one item emitted by each of the source and collection ObservableSources and + returns an item to be emitted by the resulting Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends U>> mapper,
+        @NonNull BiFunction<? super T,? super U,? extends R> combiner,
+        boolean delayErrors)
        +
        Returns an Observable that emits the results of a specified function to the pair of values emitted by the + current Observable and the mapped inner ObservableSource. +

        + +

        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the collection ObservableSource
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        mapper - a function that returns an ObservableSource for each item emitted by the current Observable
        +
        combiner - a function that combines one item emitted by each of the source and collection ObservableSources and + returns an item to be emitted by the resulting Observable
        +
        delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate + if false, the first one signaling an exception will terminate the whole sequence immediately
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends U>> mapper,
+        @NonNull BiFunction<? super T,? super U,? extends R> combiner,
+        boolean delayErrors,
+        int maxConcurrency)
        +
        Returns an Observable that emits the results of a specified function to the pair of values emitted by the + current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent + subscriptions to these ObservableSources. +

        + +

        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the collection ObservableSource
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        mapper - a function that returns an ObservableSource for each item emitted by the current Observable
        +
        combiner - a function that combines one item emitted by each of the source and collection ObservableSources and + returns an item to be emitted by the resulting Observable
        +
        maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently
        +
        delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate + if false, the first one signaling an exception will terminate the whole sequence immediately
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper or combiner is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends U>> mapper,
+        @NonNull BiFunction<? super T,? super U,? extends R> combiner,
+        boolean delayErrors,
+        int maxConcurrency,
+        int bufferSize)
        +
        Returns an Observable that emits the results of a specified function to the pair of values emitted by the + current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent + subscriptions to these ObservableSources. +

        + +

        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the collection ObservableSource
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        mapper - a function that returns an ObservableSource for each item emitted by the current Observable
        +
        combiner - a function that combines one item emitted by each of the source and collection ObservableSources and + returns an item to be emitted by the resulting Observable
        +
        maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently
        +
        delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate + if false, the first one signaling an exception will terminate the whole sequence immediately
        +
        bufferSize - the number of elements expected from the inner ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper or combiner is null
        +
        IllegalArgumentException - if maxConcurrency or bufferSize is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends U>> mapper,
+        @NonNull BiFunction<? super T,? super U,? extends R> combiner,
+        int maxConcurrency)
        +
        Returns an Observable that emits the results of a specified function to the pair of values emitted by the + current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent + subscriptions to these ObservableSources. +

        + +

        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the collection ObservableSource
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        mapper - a function that returns an ObservableSource for each item emitted by the current Observable
        +
        combiner - a function that combines one item emitted by each of the source and collection ObservableSources and + returns an item to be emitted by the resulting Observable
        +
        maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper or combiner is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + + + + + +
        +
      • +

        flatMapCompletable

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Completable flatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper,
+        boolean delayErrors)
        +
        Maps each element of the current Observable into CompletableSources, subscribes to them and + waits until the upstream and all CompletableSources complete, optionally delaying all errors. +

        + +

        +
        Scheduler:
        +
        flatMapCompletable does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        mapper - the function that received each source value and transforms them into CompletableSources.
        +
        delayErrors - if true, errors from the upstream and inner CompletableSources are delayed until all of them + terminate.
        +
        Returns:
        +
        the new Completable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        +
        • +
      + + + + + + + +
        +
      • +

        flatMapIterable

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,V> @NonNull Observable<V> flatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper,
+        @NonNull BiFunction<? super T,? super U,? extends V> combiner)
        +
        Merges Iterables generated by a mapper Function for each individual item emitted by + the current Observable into a single Observable sequence where the resulting items will + be the combination of the original item and each inner item of the respective Iterable as returned + by the resultSelector BiFunction. +

        + +

        +
        Scheduler:
        +
        flatMapIterable does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the element type of the Iterables
        +
        V - the output type as determined by the resultSelector function
        +
        Parameters:
        +
        mapper - a function that returns an Iterable sequence of values for each item emitted by the current + Observable
        +
        combiner - a function that returns an item based on the item emitted by the current Observable and the + next item of the Iterable returned for that original item by the mapper
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper or combiner is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + +
        +
      • +

        flatMapMaybe

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> flatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)
        +
        Maps each element of the current Observable into MaybeSources, subscribes to all of them + and merges their onSuccess values, in no particular order, into a single Observable sequence. +

        + +

        +
        Scheduler:
        +
        flatMapMaybe does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - the function that received each source value and transforms them into MaybeSources.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        +
        • +
      + + + +
        +
      • +

        flatMapMaybe

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> flatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper,
+        boolean delayErrors)
        +
        Maps each element of the current Observable into MaybeSources, subscribes to them + and merges their onSuccess values, in no particular order, into a single Observable sequence, + optionally delaying all errors. +

        + +

        +
        Scheduler:
        +
        flatMapMaybe does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - the function that received each source value and transforms them into MaybeSources.
        +
        delayErrors - if true, errors from the upstream and inner MaybeSources are delayed until all of them + terminate.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        +
        • +
      + + + +
        +
      • +

        flatMapSingle

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> flatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)
        +
        Maps each element of the current Observable into SingleSources, subscribes to all of them + and merges their onSuccess values, in no particular order, into a single Observable sequence. +

        + +

        +
        Scheduler:
        +
        flatMapSingle does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - the function that received each source value and transforms them into SingleSources.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        +
        • +
      + + + +
        +
      • +

        flatMapSingle

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> flatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper,
+        boolean delayErrors)
        +
        Maps each element of the current Observable into SingleSources, subscribes to them + and merges their onSuccess values, in no particular order, into a single Observable sequence, + optionally delaying all errors. +

        + +

        +
        Scheduler:
        +
        flatMapSingle does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - the function that received each source value and transforms them into SingleSources.
        +
        delayErrors - if true, errors from the upstream and inner SingleSources are delayed until each of them + terminates.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        groupBy

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K> @NonNull Observable<GroupedObservable<K,T>> groupBy(@NonNull Function<? super T,? extends K> keySelector)
        +
        Groups the items emitted by the current Observable according to a specified criterion, and emits these + grouped items as GroupedObservables. +

        + +

        + Each emitted GroupedObservable allows only a single Observer to subscribe to it during its + lifetime and if this Observer calls dispose() before the + source terminates, the next emission by the source having the same key will trigger a new + GroupedObservable emission. +

        + Note: A GroupedObservable will cache the items it is to emit until such time as it + is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those + GroupedObservables that do not concern you. Instead, you can signal to them that they may + discard their buffers by applying an operator like ignoreElements() to them. +

        + Note also that ignoring groups or subscribing later (i.e., on another thread) will result in + so-called group abandonment where a group will only contain one element and the group will be + re-created over and over as new upstream items trigger a new group. The behavior is + a trade-off between no-dataloss, upstream cancellation and excessive group creation. + +

        +
        Scheduler:
        +
        groupBy does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        Parameters:
        +
        keySelector - a function that extracts the key for each item
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if keySelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: GroupBy
        +
        +
        • +
      + + + +
        +
      • +

        groupBy

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K> @NonNull Observable<GroupedObservable<K,T>> groupBy(@NonNull Function<? super T,? extends K> keySelector,
+        boolean delayError)
        +
        Groups the items emitted by the current Observable according to a specified criterion, and emits these + grouped items as GroupedObservables. +

        + +

        + Each emitted GroupedObservable allows only a single Observer to subscribe to it during its + lifetime and if this Observer calls dispose() before the + source terminates, the next emission by the source having the same key will trigger a new + GroupedObservable emission. +

        + Note: A GroupedObservable will cache the items it is to emit until such time as it + is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those + GroupedObservables that do not concern you. Instead, you can signal to them that they may + discard their buffers by applying an operator like ignoreElements() to them. +

        + Note also that ignoring groups or subscribing later (i.e., on another thread) will result in + so-called group abandonment where a group will only contain one element and the group will be + re-created over and over as new upstream items trigger a new group. The behavior is + a trade-off between no-dataloss, upstream cancellation and excessive group creation. + +

        +
        Scheduler:
        +
        groupBy does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        Parameters:
        +
        keySelector - a function that extracts the key for each item
        +
        delayError - if true, the exception from the current Observable is delayed in each group until that specific group emitted + the normal values; if false, the exception bypasses values in the groups and is reported immediately.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if keySelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: GroupBy
        +
        +
        • +
      + + + +
        +
      • +

        groupBy

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K,V> @NonNull Observable<GroupedObservable<K,V>> groupBy(@NonNull Function<? super T,? extends K> keySelector,
+        Function<? super T,? extends V> valueSelector)
        +
        Groups the items emitted by the current Observable according to a specified criterion, and emits these + grouped items as GroupedObservables. +

        + +

        + Each emitted GroupedObservable allows only a single Observer to subscribe to it during its + lifetime and if this Observer calls dispose() before the + source terminates, the next emission by the source having the same key will trigger a new + GroupedObservable emission. +

        + Note: A GroupedObservable will cache the items it is to emit until such time as it + is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those + GroupedObservables that do not concern you. Instead, you can signal to them that they may + discard their buffers by applying an operator like ignoreElements() to them. +

        + Note also that ignoring groups or subscribing later (i.e., on another thread) will result in + so-called group abandonment where a group will only contain one element and the group will be + re-created over and over as new upstream items trigger a new group. The behavior is + a trade-off between no-dataloss, upstream cancellation and excessive group creation. + +

        +
        Scheduler:
        +
        groupBy does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        V - the element type
        +
        Parameters:
        +
        keySelector - a function that extracts the key for each item
        +
        valueSelector - a function that extracts the return element for each item
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if keySelector or valueSelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: GroupBy
        +
        +
        • +
      + + + +
        +
      • +

        groupBy

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K,V> @NonNull Observable<GroupedObservable<K,V>> groupBy(@NonNull Function<? super T,? extends K> keySelector,
+        @NonNull Function<? super T,? extends V> valueSelector,
+        boolean delayError)
        +
        Groups the items emitted by the current Observable according to a specified criterion, and emits these + grouped items as GroupedObservables. +

        + +

        + Each emitted GroupedObservable allows only a single Observer to subscribe to it during its + lifetime and if this Observer calls dispose() before the + source terminates, the next emission by the source having the same key will trigger a new + GroupedObservable emission. +

        + Note: A GroupedObservable will cache the items it is to emit until such time as it + is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those + GroupedObservables that do not concern you. Instead, you can signal to them that they may + discard their buffers by applying an operator like ignoreElements() to them. +

        + Note also that ignoring groups or subscribing later (i.e., on another thread) will result in + so-called group abandonment where a group will only contain one element and the group will be + re-created over and over as new upstream items trigger a new group. The behavior is + a trade-off between no-dataloss, upstream cancellation and excessive group creation. + +

        +
        Scheduler:
        +
        groupBy does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        V - the element type
        +
        Parameters:
        +
        keySelector - a function that extracts the key for each item
        +
        valueSelector - a function that extracts the return element for each item
        +
        delayError - if true, the exception from the current Observable is delayed in each group until that specific group emitted + the normal values; if false, the exception bypasses values in the groups and is reported immediately.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if keySelector or valueSelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: GroupBy
        +
        +
        • +
      + + + +
        +
      • +

        groupBy

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K,V> @NonNull Observable<GroupedObservable<K,V>> groupBy(@NonNull Function<? super T,? extends K> keySelector,
+        @NonNull Function<? super T,? extends V> valueSelector,
+        boolean delayError,
+        int bufferSize)
        +
        Groups the items emitted by the current Observable according to a specified criterion, and emits these + grouped items as GroupedObservables. +

        + +

        + Each emitted GroupedObservable allows only a single Observer to subscribe to it during its + lifetime and if this Observer calls dispose() before the + source terminates, the next emission by the source having the same key will trigger a new + GroupedObservable emission. +

        + Note: A GroupedObservable will cache the items it is to emit until such time as it + is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those + GroupedObservables that do not concern you. Instead, you can signal to them that they may + discard their buffers by applying an operator like ignoreElements() to them. +

        + Note also that ignoring groups or subscribing later (i.e., on another thread) will result in + so-called group abandonment where a group will only contain one element and the group will be + re-created over and over as new upstream items trigger a new group. The behavior is + a trade-off between no-dataloss, upstream cancellation and excessive group creation. + +

        +
        Scheduler:
        +
        groupBy does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type
        +
        V - the element type
        +
        Parameters:
        +
        keySelector - a function that extracts the key for each item
        +
        valueSelector - a function that extracts the return element for each item
        +
        delayError - if true, the exception from the current Observable is delayed in each group until that specific group emitted + the normal values; if false, the exception bypasses values in the groups and is reported immediately.
        +
        bufferSize - the hint for how many GroupedObservables and element in each GroupedObservable should be buffered
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if keySelector or valueSelector is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: GroupBy
        +
        +
        • +
      + + + +
        +
      • +

        groupJoin

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <TRight,TLeftEnd,TRightEnd,R> @NonNull Observable<R> groupJoin(@NonNull ObservableSource<? extends TRight> other,
+        @NonNull Function<? super T,? extends ObservableSource<TLeftEnd>> leftEnd,
+        @NonNull Function<? super TRight,? extends ObservableSource<TRightEnd>> rightEnd,
+        @NonNull BiFunction<? super T,? super Observable<TRight>,? extends R> resultSelector)
        +
        Returns an Observable that correlates two ObservableSources when they overlap in time and groups the results. +

        + There are no guarantees in what order the items get combined when multiple + items from one or both source ObservableSources overlap. +

        + +

        +
        Scheduler:
        +
        groupJoin does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        TRight - the value type of the right ObservableSource source
        +
        TLeftEnd - the element type of the left duration ObservableSources
        +
        TRightEnd - the element type of the right duration ObservableSources
        +
        R - the result type
        +
        Parameters:
        +
        other - the other ObservableSource to correlate items from the current Observable with
        +
        leftEnd - a function that returns an ObservableSource whose emissions indicate the duration of the values of + the current Observable
        +
        rightEnd - a function that returns an ObservableSource whose emissions indicate the duration of the values of + the right ObservableSource
        +
        resultSelector - a function that takes an item emitted by each ObservableSource and returns the value to be emitted + by the resulting Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if other, leftEnd, rightEnd or resultSelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: Join
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        join

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <TRight,TLeftEnd,TRightEnd,R> @NonNull Observable<R> join(@NonNull ObservableSource<? extends TRight> other,
+        @NonNull Function<? super T,? extends ObservableSource<TLeftEnd>> leftEnd,
+        @NonNull Function<? super TRight,? extends ObservableSource<TRightEnd>> rightEnd,
+        @NonNull BiFunction<? super T,? super TRight,? extends R> resultSelector)
        +
        Correlates the items emitted by two ObservableSources based on overlapping durations. +

        + There are no guarantees in what order the items get combined when multiple + items from one or both source ObservableSources overlap. +

        + +

        +
        Scheduler:
        +
        join does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        TRight - the value type of the right ObservableSource source
        +
        TLeftEnd - the element type of the left duration ObservableSources
        +
        TRightEnd - the element type of the right duration ObservableSources
        +
        R - the result type
        +
        Parameters:
        +
        other - the second ObservableSource to join items from
        +
        leftEnd - a function to select a duration for each item emitted by the current Observable, used to + determine overlap
        +
        rightEnd - a function to select a duration for each item emitted by the right ObservableSource, used to + determine overlap
        +
        resultSelector - a function that computes an item to be emitted by the resulting Observable for any two + overlapping items emitted by the two ObservableSources
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if other, leftEnd, rightEnd or resultSelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: Join
        +
        +
        • +
      + + + + + + + + + + + + + + + + + +
        +
      • +

        lift

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> lift(@NonNull ObservableOperator<? extends R,? super T> lifter)
        +
        This method requires advanced knowledge about building operators, please consider + other standard composition methods first; + Returns an Observable which, when subscribed to, invokes the apply(Observer) method + of the provided ObservableOperator for each individual downstream Observer and allows the + insertion of a custom operator by accessing the downstream's Observer during this subscription phase + and providing a new Observer, containing the custom operator's intended business logic, that will be + used in the subscription process going further upstream. +

        + Generally, such a new Observer will wrap the downstream's Observer and forwards the + onNext, onError and onComplete events from the upstream directly or according to the + emission pattern the custom operator's business logic requires. In addition, such operator can intercept the + flow control calls of dispose and isDisposed that would have traveled upstream and perform + additional actions depending on the same business logic requirements. +

        + Example: + 

        
+ // Step 1: Create the consumer type that will be returned by the ObservableOperator.apply():
+
+ public final class CustomObserver<T> implements Observer<T>, Disposable {
+
+     // The downstream's Observer that will receive the onXXX events
+     final Observer<? super String> downstream;
+
+     // The connection to the upstream source that will call this class' onXXX methods
+     Disposable upstream;
+
+     // The constructor takes the downstream subscriber and usually any other parameters
+     public CustomObserver(Observer<? super String> downstream) {
+         this.downstream = downstream;
+     }
+
+     // In the subscription phase, the upstream sends a Disposable to this class
+     // and subsequently this class has to send a Disposable to the downstream.
+     // Note that relaying the upstream's Disposable directly is not allowed in RxJava
+     @Override
+     public void onSubscribe(Disposable d) {
+         if (upstream != null) {
+             d.dispose();
+         } else {
+             upstream = d;
+             downstream.onSubscribe(this);
+         }
+     }
+
+     // The upstream calls this with the next item and the implementation's
+     // responsibility is to emit an item to the downstream based on the intended
+     // business logic, or if it can't do so for the particular item,
+        // request more from the upstream
+     @Override
+     public void onNext(T item) {
+         String str = item.toString();
+         if (str.length() < 2) {
+             downstream.onNext(str);
+         }
+         // Observable doesn't support backpressure, therefore, there is no
+         // need or opportunity to call upstream.request(1) if an item
+         // is not produced to the downstream
+     }
+
+     // Some operators may handle the upstream's error while others
+     // could just forward it to the downstream.
+     @Override
+     public void onError(Throwable throwable) {
+         downstream.onError(throwable);
+     }
+
+     // When the upstream completes, usually the downstream should complete as well.
+     @Override
+     public void onComplete() {
+         downstream.onComplete();
+     }
+
+     // Some operators may use their own resources which should be cleaned up if
+     // the downstream disposes the flow before it completed. Operators without
+     // resources can simply forward the dispose to the upstream.
+     // In some cases, a disposed flag may be set by this method so that other parts
+     // of this class may detect the dispose and stop sending events
+     // to the downstream.
+     @Override
+     public void dispose() {
+         upstream.dispose();
+     }
+
+     // Some operators may simply forward the call to the upstream while others
+     // can return the disposed flag set in dispose().
+     @Override
+     public boolean isDisposed() {
+         return upstream.isDisposed();
+     }
+ }
+
+ // Step 2: Create a class that implements the ObservableOperator interface and
+ //         returns the custom consumer type from above in its apply() method.
+ //         Such class may define additional parameters to be submitted to
+ //         the custom consumer type.
+
+ final class CustomOperator<T> implements ObservableOperator<String, T> {
+     @Override
+     public Observer<T> apply(Observer<? super String> downstream) {
+         return new CustomObserver<T>(downstream);
+     }
+ }
+
+ // Step 3: Apply the custom operator via lift() in a flow by creating an instance of it
+ //         or reusing an existing one.
+
+ Observable.range(5, 10)
+ .lift(new CustomOperator<Integer>())
+ .test()
+ .assertResult("5", "6", "7", "8", "9");
+
        +

        + Creating custom operators can be complicated and it is recommended one consults the + RxJava wiki: Writing operators page about + the tools, requirements, rules, considerations and pitfalls of implementing them. +

        + Note that implementing custom operators via this lift() method adds slightly more overhead by requiring + an additional allocation and indirection per assembled flows. Instead, extending the abstract Observable + class and creating an ObservableTransformer with it is recommended. +

        + Note also that it is not possible to stop the subscription phase in lift() as the apply() method + requires a non-null Observer instance to be returned, which is then unconditionally subscribed to + the current Observable. For example, if the operator decided there is no reason to subscribe to the + upstream source because of some optimization possibility or a failure to prepare the operator, it still has to + return an Observer that should immediately dispose the upstream's Disposable in its + onSubscribe method. Again, using an ObservableTransformer and extending the Observable is + a better option as subscribeActual(io.reactivex.rxjava3.core.Observer<? super T>) can decide to not subscribe to its upstream after all. +

        +
        Scheduler:
        +
        lift does not operate by default on a particular Scheduler, however, the + ObservableOperator may use a Scheduler to support its own asynchronous behavior.
        +
        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        lifter - the ObservableOperator that receives the downstream's Observer and should return + an Observer with custom behavior to be used as the consumer for the current + Observable.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if lifter is null
        +
        See Also:
        +
        RxJava wiki: Writing operators, +compose(ObservableTransformer)
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        mergeWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> mergeWith(@NonNull SingleSource<? extends T> other)
        +
        Merges the sequence of items of the current Observable with the success value of the other SingleSource. +

        + +

        + The success value of the other SingleSource can get interleaved at any point of the current + Observable sequence. +

        +
        Scheduler:
        +
        mergeWith does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.10 - experimental

        +
        +
        Parameters:
        +
        other - the SingleSource whose success value to merge with
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if other is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        mergeWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> mergeWith(@NonNull MaybeSource<? extends T> other)
        +
        Merges the sequence of items of the current Observable with the success value of the other MaybeSource + or waits both to complete normally if the MaybeSource is empty. +

        + +

        + The success value of the other MaybeSource can get interleaved at any point of the current + Observable sequence. +

        +
        Scheduler:
        +
        mergeWith does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.10 - experimental

        +
        +
        Parameters:
        +
        other - the MaybeSource which provides a success value to merge with or completes
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if other is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        observeOn

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> observeOn(@NonNull Scheduler scheduler,
+        boolean delayError,
+        int bufferSize)
        +
        Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, + asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications. +

        + +

        + This operator keeps emitting as many signals as it can on the given Scheduler's worker thread, + which may result in a longer than expected occupation of this thread. In other terms, + it does not allow per-signal fairness in case the worker runs on a shared underlying thread. + If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +

        "Island size" indicates how large chunks the unbounded buffer allocates to store the excess elements waiting to be consumed + on the other side of the asynchronous boundary. Values below 16 are not recommended in performance sensitive scenarios.

        +
        +
        Parameters:
        +
        scheduler - the Scheduler to notify Observers on
        +
        delayError - indicates if the onError notification may not cut ahead of onNext notification on the other side of the + scheduling boundary. If true a sequence ending in onError will be replayed in the same order as was received + from upstream
        +
        bufferSize - the size of the buffer.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if scheduler is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: ObserveOn, +RxJava Threading Examples, +subscribeOn(io.reactivex.rxjava3.core.Scheduler), +observeOn(Scheduler), +observeOn(Scheduler, boolean), +delay(long, TimeUnit, Scheduler, boolean)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        onErrorComplete

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> onErrorComplete()
        +
        Returns an Observable instance that if the current Observable emits an error, it will emit an onComplete + and swallow the throwable. +

        + +

        +
        Scheduler:
        +
        onErrorComplete does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Observable instance
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        onErrorComplete

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Observable<T> onErrorComplete(@NonNull Predicate<? super Throwable> predicate)
        +
        Returns an Observable instance that if the current Observable emits an error and the predicate returns + true, it will emit an onComplete and swallow the throwable. +

        + +

        +
        Scheduler:
        +
        onErrorComplete does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        predicate - the predicate to call when an Throwable is emitted which should return true + if the Throwable should be swallowed and replaced with an onComplete.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if predicate is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        onErrorResumeNext

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> onErrorResumeNext(@NonNull Function<? super Throwable,? extends ObservableSource<? extends T>> fallbackSupplier)
        +
        Resumes the flow with an ObservableSource returned for the failure Throwable of the current Observable by a + function instead of signaling the error via onError. +

        + +

        + By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to + its Observer, the ObservableSource invokes its Observer's onError method, and then quits + without invoking any more of its Observer's methods. The onErrorResumeNext method changes this + behavior. If you pass a function that returns an ObservableSource (resumeFunction) to + onErrorResumeNext, if the original ObservableSource encounters an error, instead of invoking its + Observer's onError method, it will instead relinquish control to the ObservableSource returned from + resumeFunction, which will invoke the Observer's onNext method if it is + able to do so. In such a case, because no ObservableSource necessarily invokes onError, the Observer + may never know that an error happened. +

        + You can use this to prevent errors from propagating or to supply fallback data should errors be + encountered. +

        +
        Scheduler:
        +
        onErrorResumeNext does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        fallbackSupplier - a function that returns an ObservableSource that will take over if the current Observable encounters + an error
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if fallbackSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: Catch
        +
        +
        • +
      + + + +
        +
      • +

        onErrorResumeWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> onErrorResumeWith(@NonNull ObservableSource<? extends T> fallback)
        +
        Resumes the flow with the given ObservableSource when the current Observable fails instead of + signaling the error via onError. +

        + +

        + By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to + its Observer, the ObservableSource invokes its Observer's onError method, and then quits + without invoking any more of its Observer's methods. The onErrorResumeWith method changes this + behavior. If you pass another ObservableSource (next) to an ObservableSource's + onErrorResumeWith method, if the original ObservableSource encounters an error, instead of invoking its + Observer's onError method, it will instead relinquish control to next which + will invoke the Observer's onNext method if it is able to do so. In such a case, + because no ObservableSource necessarily invokes onError, the Observer may never know that an error + happened. +

        + You can use this to prevent errors from propagating or to supply fallback data should errors be + encountered. +

        +
        Scheduler:
        +
        onErrorResumeWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        fallback - the next ObservableSource source that will take over if the current Observable encounters + an error
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if fallback is null
        +
        See Also:
        +
        ReactiveX operators documentation: Catch
        +
        +
        • +
      + + + +
        +
      • +

        onErrorReturn

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> onErrorReturn(@NonNull Function<? super Throwable,? extends T> itemSupplier)
        +
        Ends the flow with a last item returned by a function for the Throwable error signaled by the current + Observable instead of signaling the error via onError. +

        + +

        + By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to + its Observer, the ObservableSource invokes its Observer's onError method, and then quits + without invoking any more of its Observer's methods. The onErrorReturn method changes this + behavior. If you pass a function (resumeFunction) to an ObservableSource's onErrorReturn + method, if the original ObservableSource encounters an error, instead of invoking its Observer's + onError method, it will instead emit the return value of resumeFunction. +

        + You can use this to prevent errors from propagating or to supply fallback data should errors be + encountered. +

        +
        Scheduler:
        +
        onErrorReturn does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        itemSupplier - a function that returns a single value that will be emitted along with a regular onComplete in case + the current Observable signals an onError event
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if itemSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: Catch
        +
        +
        • +
      + + + + + +
        +
      • +

        onErrorReturnItem

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> onErrorReturnItem(@NonNull T item)
        +
        Ends the flow with the given last item when the current Observable fails instead of signaling the error via onError. +

        + +

        + By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to + its Observer, the ObservableSource invokes its Observer's onError method, and then quits + without invoking any more of its Observer's methods. The onErrorReturn method changes this + behavior. If you pass a function (resumeFunction) to an ObservableSource's onErrorReturn + method, if the original ObservableSource encounters an error, instead of invoking its Observer's + onError method, it will instead emit the return value of resumeFunction. +

        + You can use this to prevent errors from propagating or to supply fallback data should errors be + encountered. +

        +
        Scheduler:
        +
        onErrorReturnItem does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        item - the value that is emitted along with a regular onComplete in case the current + Observable signals an exception
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if item is null
        +
        See Also:
        +
        ReactiveX operators documentation: Catch
        +
        +
        • +
      + + + +
        +
      • +

        onTerminateDetach

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> onTerminateDetach()
        +
        Nulls out references to the upstream producer and downstream Observer if + the sequence is terminated or downstream calls dispose(). +

        + +

        +
        Scheduler:
        +
        onTerminateDetach does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Observable instance + the sequence is terminated or downstream calls dispose()
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        reduce

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Maybe<T> reduce(@NonNull BiFunction<T,T,T> reducer)
        +
        Returns a Maybe that applies a specified accumulator function to the first item emitted by the current + Observable, then feeds the result of that function along with the second item emitted by the current + Observable into the same function, and so on until all items have been emitted by the current and finite Observable, + and emits the final result from the final call to your function as its sole item. +

        + +

        + This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," + "compress," or "inject" in other programming contexts. Groovy, for instance, has an inject method + that does a similar operation on lists. +

        + Note that this operator requires the upstream to signal onComplete for the accumulator object to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        reduce does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        reducer - an accumulator function to be invoked on each item emitted by the current Observable, whose + result will be used in the next accumulator call
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if reducer is null
        +
        See Also:
        +
        ReactiveX operators documentation: Reduce, +Wikipedia: Fold (higher-order function)
        +
        +
        • +
      + + + + + +
        +
      • +

        reduce

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Single<R> reduce(R seed,
+        @NonNull BiFunction<R,? super T,R> reducer)
        +
        Returns a Single that applies a specified accumulator function to the first item emitted by the current + Observable and a specified seed value, then feeds the result of that function along with the second item + emitted by the current Observable into the same function, and so on until all items have been emitted by the + current and finite Observable, emitting the final result from the final call to your function as its sole item. +

        + +

        + This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," + "compress," or "inject" in other programming contexts. Groovy, for instance, has an inject method + that does a similar operation on lists. +

        + Note that the seed is shared among all subscribers to the resulting Observable + and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer + the application of this operator via defer(Supplier): + 

        
+ ObservableSource<T> source = ...
+ Single.defer(() -> source.reduce(new ArrayList<>(), (list, item) -> list.add(item)));
+
+ // alternatively, by using compose to stay fluent
+
+ source.compose(o ->
+     Observable.defer(() -> o.reduce(new ArrayList<>(), (list, item) -> list.add(item)).toObservable())
+ ).firstOrError();
+
+ // or, by using reduceWith instead of reduce
+
+ source.reduceWith(() -> new ArrayList<>(), (list, item) -> list.add(item)));
+
        +

        + Note that this operator requires the upstream to signal onComplete for the accumulator object to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        reduce does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the accumulator and output value type
        +
        Parameters:
        +
        seed - the initial (seed) accumulator value
        +
        reducer - an accumulator function to be invoked on each item emitted by the current Observable, the + result of which will be used in the next accumulator call
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if seed or reducer is null
        +
        See Also:
        +
        ReactiveX operators documentation: Reduce, +Wikipedia: Fold (higher-order function), +reduceWith(Supplier, BiFunction)
        +
        +
        • +
      + + + +
        +
      • +

        reduceWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Single<R> reduceWith(@NonNull Supplier<R> seedSupplier,
+        @NonNull BiFunction<R,? super T,R> reducer)
        +
        Returns a Single that applies a specified accumulator function to the first item emitted by the current + Observable and a seed value derived from calling a specified seedSupplier, then feeds the result + of that function along with the second item emitted by the current Observable into the same function, + and so on until all items have been emitted by the current and finite Observable, emitting the final result + from the final call to your function as its sole item. +

        + +

        + This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," + "compress," or "inject" in other programming contexts. Groovy, for instance, has an inject method + that does a similar operation on lists. +

        + Note that this operator requires the upstream to signal onComplete for the accumulator object to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        reduceWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the accumulator and output value type
        +
        Parameters:
        +
        seedSupplier - the Supplier that provides the initial (seed) accumulator value for each individual Observer
        +
        reducer - an accumulator function to be invoked on each item emitted by the current Observable, the + result of which will be used in the next accumulator call
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if seedSupplier or reducer is null
        +
        See Also:
        +
        ReactiveX operators documentation: Reduce, +Wikipedia: Fold (higher-order function)
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        repeatWhen

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> repeatWhen(@NonNull Function<? super Observable<Object>,? extends ObservableSource<?>> handler)
        +
        Returns an Observable that emits the same values as the current Observable with the exception of an + onComplete. An onComplete notification from the source will result in the emission of + a void item to the ObservableSource provided as an argument to the notificationHandler + function. If that ObservableSource calls onComplete or onError then repeatWhen will + call onComplete or onError on the child subscription. Otherwise, the current Observable + will be resubscribed. +

        + +

        +
        Scheduler:
        +
        repeatWhen does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        handler - receives an ObservableSource of notifications with which a user can complete or error, aborting the repeat.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if handler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Repeat
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector,
+        int bufferSize)
        +
        Returns an Observable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableObservable that shares a single subscription to the current Observable, + replaying bufferSize notifications. +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. +

        + +

        +
        Scheduler:
        +
        This version of replay does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        selector - the selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Observable
        +
        bufferSize - the buffer size that limits the number of items the connectable Observable can replay
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if selector is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay, +replay(Function, int, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector,
+        int bufferSize,
+        boolean eagerTruncate)
        +
        Returns an Observable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableObservable that shares a single subscription to the current Observable, + replaying bufferSize notifications. +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. +

        + +

        +
        Scheduler:
        +
        This version of replay does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        selector - the selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Observable
        +
        bufferSize - the buffer size that limits the number of items the connectable Observable can replay
        +
        eagerTruncate - if true, whenever the internal buffer is truncated to the given bufferSize, the + oldest item will be guaranteed dereferenced, thus avoiding unexpected retention
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if selector is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector,
+        int bufferSize,
+        long time,
+        @NonNull TimeUnit unit)
        +
        Returns an Observable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableObservable that shares a single subscription to the current Observable, + replaying no more than bufferSize items that were emitted within a specified time window. +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. +

        + +

        +
        Scheduler:
        +
        This version of replay operates by default on the computation Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        selector - a selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Observable
        +
        bufferSize - the buffer size that limits the number of items the connectable Observable can replay
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if selector or unit is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector,
+        int bufferSize,
+        long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns an Observable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableObservable that shares a single subscription to the current Observable, + replaying no more than bufferSize items that were emitted within a specified time window. +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        selector - a selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Observable
        +
        bufferSize - the buffer size that limits the number of items the connectable Observable can replay
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that is the time source for the window
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        NullPointerException - if selector, unit or scheduler is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay, +replay(Function, int, long, TimeUnit, Scheduler, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector,
+        int bufferSize,
+        long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean eagerTruncate)
        +
        Returns an Observable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableObservable that shares a single subscription to the current Observable, + replaying no more than bufferSize items that were emitted within a specified time window. +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        selector - a selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Observable
        +
        bufferSize - the buffer size that limits the number of items the connectable Observable can replay
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that is the time source for the window
        +
        eagerTruncate - if true, whenever the internal buffer is truncated to the given bufferSize/age, the + oldest item will be guaranteed dereferenced, thus avoiding unexpected retention
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if selector, unit or scheduler is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector,
+        long time,
+        @NonNull TimeUnit unit)
        +
        Returns an Observable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableObservable that shares a single subscription to the current Observable, + replaying all items that were emitted within a specified time window. +

        + +

        +
        Scheduler:
        +
        This version of replay operates by default on the computation Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        selector - a selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Observable
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if selector or unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + + + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector,
+        long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean eagerTruncate)
        +
        Returns an Observable that emits items that are the results of invoking a specified selector on items + emitted by a ConnectableObservable that shares a single subscription to the current Observable, + replaying all items that were emitted within a specified time window. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Type Parameters:
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        selector - a selector function, which can use the multicasted sequence as many times as needed, without + causing multiple subscriptions to the current Observable
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        scheduler - the scheduler that is the time source for the window
        +
        eagerTruncate - if true, whenever the internal buffer is truncated to the given age, the + oldest item will be guaranteed dereferenced, thus avoiding unexpected retention
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if selector, unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull ConnectableObservable<T> replay(int bufferSize)
        +
        Returns a ConnectableObservable that shares a single subscription to the current Observable that + replays at most bufferSize items emitted by the current Observable. A connectable Observable resembles + an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only + when its connect method is called. +

        + +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. + To ensure no beyond-bufferSize items are referenced, + use the replay(int, boolean) overload with eagerTruncate = true. +

        +
        Scheduler:
        +
        This version of replay does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        bufferSize - the buffer size that limits the number of items that can be replayed
        +
        Returns:
        +
        the new ConnectableObservable instance
        +
        Throws:
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay, +replay(int, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull ConnectableObservable<T> replay(int bufferSize,
+        boolean eagerTruncate)
        +
        Returns a ConnectableObservable that shares a single subscription to the current Observable that + replays at most bufferSize items emitted by the current Observable. A connectable Observable resembles + an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only + when its connect method is called. +

        + +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. + To ensure no beyond-bufferSize items are referenced, set eagerTruncate = true. +

        +
        Scheduler:
        +
        This version of replay does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        bufferSize - the buffer size that limits the number of items that can be replayed
        +
        eagerTruncate - if true, whenever the internal buffer is truncated to the given bufferSize/age, the + oldest item will be guaranteed dereferenced, thus avoiding unexpected retention
        +
        Returns:
        +
        the new ConnectableObservable instance
        +
        Throws:
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull ConnectableObservable<T> replay(int bufferSize,
+        long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean eagerTruncate)
        +
        Returns a ConnectableObservable that shares a single subscription to the current Observable and + that replays a maximum of bufferSize items that are emitted within a specified time window. A + connectable Observable resembles an ordinary Observable, except that it does not begin emitting items + when it is subscribed to, but only when its connect method is called. +

        + +

        + Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than + bufferSize source emissions. + To ensure no out-of-date or beyond-bufferSize items + are referenced, set eagerTruncate = true. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        bufferSize - the buffer size that limits the number of items that can be replayed
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        scheduler - the scheduler that is used as a time source for the window
        +
        eagerTruncate - if true, whenever the internal buffer is truncated to the given bufferSize/age, the + oldest item will be guaranteed dereferenced, thus avoiding unexpected retention
        +
        Returns:
        +
        the new ConnectableObservable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull ConnectableObservable<T> replay(long time,
+        @NonNull TimeUnit unit)
        +
        Returns a ConnectableObservable that shares a single subscription to the current Observable and + replays all items emitted by the current Observable within a specified time window. A connectable Observable + resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, + but only when its connect method is called. +

        + +

        +
        Scheduler:
        +
        This version of replay operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        Returns:
        +
        the new ConnectableObservable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + + + + + +
        +
      • +

        replay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull ConnectableObservable<T> replay(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean eagerTruncate)
        +
        Returns a ConnectableObservable that shares a single subscription to the current Observable and + replays all items emitted by the current Observable within a specified time window. A connectable Observable + resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, + but only when its connect method is called. +

        + +

        + Note that the internal buffer may retain strong references to the oldest item. To ensure no out-of-date items + are referenced, set eagerTruncate = true. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        time - the duration of the window in which the replayed items must have been emitted
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that is the time source for the window
        +
        eagerTruncate - if true, whenever the internal buffer is truncated to the given bufferSize/age, the + oldest item will be guaranteed dereferenced, thus avoiding unexpected retention
        +
        Returns:
        +
        the new ConnectableObservable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Replay
        +
        +
        • +
      + + + +
        +
      • +

        retry

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> retry()
        +
        Returns an Observable that mirrors the current Observable, resubscribing to it if it calls onError + (infinite retry count). +

        + +

        + If the current Observable calls Observer.onError(java.lang.Throwable), this method will resubscribe to the current + Observable rather than propagating the onError call. +

        + Any and all items emitted by the current Observable will be emitted by the resulting Observable, even + those emitted during failed subscriptions. For example, if the current Observable fails at first but emits + [1, 2] then succeeds the second time and emits [1, 2, 3, 4, 5] then the complete sequence + of emissions and notifications would be [1, 2, 1, 2, 3, 4, 5, onComplete]. +

        +
        Scheduler:
        +
        retry does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Observable instance
        +
        See Also:
        +
        ReactiveX operators documentation: Retry
        +
        +
        • +
      + + + + + + + +
        +
      • +

        retry

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> retry(long times)
        +
        Returns an Observable that mirrors the current Observable, resubscribing to it if it calls onError + up to a specified number of retries. +

        + +

        + If the current Observable calls Observer.onError(java.lang.Throwable), this method will resubscribe to the current + Observable for a maximum of count resubscriptions rather than propagating the + onError call. +

        + Any and all items emitted by the current Observable will be emitted by the resulting Observable, even + those emitted during failed subscriptions. For example, if the current Observable fails at first but emits + [1, 2] then succeeds the second time and emits [1, 2, 3, 4, 5] then the complete sequence + of emissions and notifications would be [1, 2, 1, 2, 3, 4, 5, onComplete]. +

        +
        Scheduler:
        +
        retry does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        times - the number of times to resubscribe if the current Observable fails
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        IllegalArgumentException - if times is negative
        +
        See Also:
        +
        ReactiveX operators documentation: Retry
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        retryWhen

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> retryWhen(@NonNull Function<? super Observable<Throwable>,? extends ObservableSource<?>> handler)
        +
        Returns an Observable that emits the same values as the current Observable with the exception of an + onError. An onError notification from the source will result in the emission of a + Throwable item to the Observable provided as an argument to the notificationHandler + function. If that Observable calls onComplete or onError then retry will call + onComplete or onError on the child subscription. Otherwise, the current Observable + will be resubscribed. +

        + +

        + Example: + + This retries 3 times, each time incrementing the number of seconds it waits. + + 

        
+  Observable.create((ObservableEmitter<? super String> s) -> {
+      System.out.println("subscribing");
+      s.onError(new RuntimeException("always fails"));
+  }).retryWhen(attempts -> {
+      return attempts.zipWith(Observable.range(1, 3), (n, i) -> i).flatMap(i -> {
+          System.out.println("delay retry by " + i + " second(s)");
+          return Observable.timer(i, TimeUnit.SECONDS);
+      });
+  }).blockingForEach(System.out::println);
+
        + + Output is: + + 
         
+ subscribing
+ delay retry by 1 second(s)
+ subscribing
+ delay retry by 2 second(s)
+ subscribing
+ delay retry by 3 second(s)
+ subscribing
+
        +

        + Note that the inner ObservableSource returned by the handler function should signal + either onNext, onError or onComplete in response to the received + Throwable to indicate the operator should retry or terminate. If the upstream to + the operator is asynchronous, signaling onNext followed by onComplete immediately may + result in the sequence to be completed immediately. Similarly, if this inner + ObservableSource signals onError or onComplete while the upstream is + active, the sequence is terminated with the same signal immediately. +

        + The following example demonstrates how to retry an asynchronous source with a delay: + 

        
+ Observable.timer(1, TimeUnit.SECONDS)
+     .doOnSubscribe(s -> System.out.println("subscribing"))
+     .map(v -> { throw new RuntimeException(); })
+     .retryWhen(errors -> {
+         AtomicInteger counter = new AtomicInteger();
+         return errors
+                   .takeWhile(e -> counter.getAndIncrement() != 3)
+                   .flatMap(e -> {
+                       System.out.println("delay retry by " + counter.get() + " second(s)");
+                       return Observable.timer(counter.get(), TimeUnit.SECONDS);
+                   });
+     })
+     .blockingSubscribe(System.out::println, System.out::println);
+
        +
        +
        Scheduler:
        +
        retryWhen does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        handler - receives an Observable of notifications with which a user can complete or error, aborting the + retry
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if handler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Retry
        +
        +
        • +
      + + + +
        +
      • +

        safeSubscribe

        +
        @SchedulerSupport(value="none")
+public final void safeSubscribe(@NonNull Observer<? super T> observer)
        +
        Subscribes to the current Observable and wraps the given Observer into a SafeObserver + (if not already a SafeObserver) that + deals with exceptions thrown by a misbehaving Observer (that doesn't follow the + Reactive Streams specification). +
        +
        Scheduler:
        +
        safeSubscribe does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        observer - the incoming Observer instance
        +
        Throws:
        +
        NullPointerException - if observer is null
        +
        +
        • +
      + + + + + + + +
        +
      • +

        sample

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Observable<T> sample(long period,
+        @NonNull TimeUnit unit,
+        boolean emitLast)
        +
        Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable + within periodic time intervals and optionally emit the very last upstream item when the upstream completes. +

        + +

        +
        Scheduler:
        +
        sample operates by default on the computation Scheduler.
        +
        + +

        History: 2.0.5 - experimental

        +
        +
        Parameters:
        +
        period - the sampling rate
        +
        unit - the TimeUnit in which period is defined
        +
        emitLast - if true and the upstream completes while there is still an unsampled item available, + that item is emitted to downstream before completion + if false, an unsampled last item is ignored.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        2.1
        +
        See Also:
        +
        ReactiveX operators documentation: Sample, +throttleLast(long, TimeUnit)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        sample

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> sample(long period,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean emitLast)
        +
        Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable + within periodic time intervals, where the intervals are defined on a particular Scheduler + and optionally emit the very last upstream item when the upstream completes. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        + +

        History: 2.0.5 - experimental

        +
        +
        Parameters:
        +
        period - the sampling rate
        +
        unit - the TimeUnit in which period is defined
        +
        scheduler - the Scheduler to use when sampling
        +
        emitLast - if true and the upstream completes while there is still an unsampled item available, + that item is emitted to downstream before completion + if false, an unsampled last item is ignored.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        Since:
        +
        2.1
        +
        See Also:
        +
        ReactiveX operators documentation: Sample, +throttleLast(long, TimeUnit, Scheduler)
        +
        +
        • +
      + + + +
        +
      • +

        sample

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> sample(long period,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean emitLast,
+        @NonNull Consumer<? super T> onDropped)
        +
        Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable + within periodic time intervals, where the intervals are defined on a particular Scheduler. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        period - the sampling rate
        +
        unit - the TimeUnit in which period is defined
        +
        scheduler - the Scheduler to use when sampling
        +
        emitLast - if true and the upstream completes while there is still an unsampled item available, + that item is emitted to downstream before completion + if false, an unsampled last item is ignored.
        +
        onDropped - called with the current entry when it has been replaced by a new one
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null or onDropped is null
        +
        Since:
        +
        3.1.6 - Experimental
        +
        See Also:
        +
        ReactiveX operators documentation: Sample, +throttleLast(long, TimeUnit, Scheduler)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        sample

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U> @NonNull Observable<T> sample(@NonNull ObservableSource<U> sampler,
+        boolean emitLast)
        +
        Returns an Observable that, when the specified sampler ObservableSource emits an item or completes, + emits the most recently emitted item (if any) emitted by the current Observable since the previous + emission from the sampler ObservableSource + and optionally emit the very last upstream item when the upstream or other ObservableSource complete. +

        + +

        +
        Scheduler:
        +
        This version of sample does not operate by default on a particular Scheduler.
        +
        + +

        History: 2.0.5 - experimental

        +
        +
        Type Parameters:
        +
        U - the element type of the sampler ObservableSource
        +
        Parameters:
        +
        sampler - the ObservableSource to use for sampling the current Observable
        +
        emitLast - if true and the upstream completes while there is still an unsampled item available, + that item is emitted to downstream before completion + if false, an unsampled last item is ignored.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if sampler is null
        +
        Since:
        +
        2.1
        +
        See Also:
        +
        ReactiveX operators documentation: Sample
        +
        +
        • +
      + + + +
        +
      • +

        scan

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> scan(@NonNull BiFunction<T,T,T> accumulator)
        +
        Returns an Observable that emits the first value emitted by the current Observable, then emits one value + for each subsequent value emitted by the current Observable. Each emission after the first is the result of + applying the specified accumulator function to the previous emission and the corresponding value from the current Observable. +

        + +

        + This sort of function is sometimes called an accumulator. +

        +
        Scheduler:
        +
        scan does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        accumulator - an accumulator function to be invoked on each item emitted by the current Observable, whose + result will be emitted to Observers via onNext and used in the + next accumulator call
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if accumulator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Scan
        +
        +
        • +
      + + + + + +
        +
      • +

        scan

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> scan(@NonNull R initialValue,
+        @NonNull BiFunction<R,? super T,R> accumulator)
        +
        Returns an Observable that emits the provided initial (seed) value, then emits one value for each value emitted + by the current Observable. Each emission after the first is the result of applying the specified accumulator + function to the previous emission and the corresponding value from the current Observable. +

        + +

        + This sort of function is sometimes called an accumulator. +

        + Note that the Observable that results from this method will emit initialValue as its first + emitted item. +

        + Note that the initialValue is shared among all subscribers to the resulting Observable + and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer + the application of this operator via defer(Supplier): + 

        
+ ObservableSource<T> source = ...
+ Observable.defer(() -> source.scan(new ArrayList<>(), (list, item) -> list.add(item)));
+
+ // alternatively, by using compose to stay fluent
+
+ source.compose(o ->
+     Observable.defer(() -> o.scan(new ArrayList<>(), (list, item) -> list.add(item)))
+ );
+
        +
        +
        Scheduler:
        +
        scan does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the initial, accumulator and result type
        +
        Parameters:
        +
        initialValue - the initial (seed) accumulator item
        +
        accumulator - an accumulator function to be invoked on each item emitted by the current Observable, whose + result will be emitted to Observers via onNext and used in the + next accumulator call
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if initialValue or accumulator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Scan
        +
        +
        • +
      + + + +
        +
      • +

        scanWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> scanWith(@NonNull Supplier<R> seedSupplier,
+        @NonNull BiFunction<R,? super T,R> accumulator)
        +
        Returns an Observable that emits the provided initial (seed) value, then emits one value for each value emitted + by the current Observable. Each emission after the first is the result of applying the specified accumulator + function to the previous emission and the corresponding value from the current Observable. +

        + +

        + This sort of function is sometimes called an accumulator. +

        + Note that the Observable that results from this method will emit the value returned + by the seedSupplier as its first item. +

        +
        Scheduler:
        +
        scanWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the initial, accumulator and result type
        +
        Parameters:
        +
        seedSupplier - a Supplier that returns the initial (seed) accumulator item for each individual Observer
        +
        accumulator - an accumulator function to be invoked on each item emitted by the current Observable, whose + result will be emitted to Observers via onNext and used in the + next accumulator call
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if seedSupplier or accumulator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Scan
        +
        +
        • +
      + + + +
        +
      • +

        serialize

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> serialize()
        +
        Forces the current Observable's emissions and notifications to be serialized and for it to obey + the ObservableSource contract in other ways. +

        + It is possible for an Observable to invoke its Observers' methods asynchronously, perhaps from + different threads. This could make such an Observable poorly-behaved, in that it might try to invoke + onComplete or onError before one of its onNext invocations, or it might call + onNext from two different threads concurrently. You can force such an Observable to be + well-behaved and sequential by applying the serialize method to it. +

        + +

        +
        Scheduler:
        +
        serialize does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Observable instance
        +
        See Also:
        +
        ReactiveX operators documentation: Serialize
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        skipLast

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> skipLast(int count)
        +
        Returns an Observable that drops a specified number of items from the end of the sequence emitted by the + current Observable. +

        + +

        + This Observer accumulates a queue long enough to store the first count items. As more items are + received, items are taken from the front of the queue and emitted by the returned Observable. This causes + such items to be delayed. +

        +
        Scheduler:
        +
        This version of skipLast does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - number of items to drop from the end of the source sequence
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        IllegalArgumentException - if count is negative
        +
        See Also:
        +
        ReactiveX operators documentation: SkipLast
        +
        +
        • +
      + + + +
        +
      • +

        skipLast

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:trampoline")
+ @NonNull
+public final @NonNull Observable<T> skipLast(long time,
+        @NonNull TimeUnit unit)
        +
        Returns an Observable that drops items emitted by the current Observable during a specified time window + before the source completes. +

        + +

        + Note: this action will cache the latest items arriving in the specified time window. +

        +
        Scheduler:
        +
        skipLast does not operate on any particular scheduler but uses the current time + from the trampoline Scheduler.
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: SkipLast
        +
        +
        • +
      + + + +
        +
      • +

        skipLast

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:trampoline")
+ @NonNull
+public final @NonNull Observable<T> skipLast(long time,
+        @NonNull TimeUnit unit,
+        boolean delayError)
        +
        Returns an Observable that drops items emitted by the current Observable during a specified time window + before the source completes. +

        + +

        + Note: this action will cache the latest items arriving in the specified time window. +

        +
        Scheduler:
        +
        skipLast does not operate on any particular scheduler but uses the current time + from the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        delayError - if true, an exception signaled by the current Observable is delayed until the regular elements are consumed + by the downstream; if false, an exception is immediately signaled and all regular elements dropped
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: SkipLast
        +
        +
        • +
      + + + +
        +
      • +

        skipLast

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> skipLast(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns an Observable that drops items emitted by the current Observable during a specified time window + (defined on a specified scheduler) before the source completes. +

        + +

        + Note: this action will cache the latest items arriving in the specified time window. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use for tracking the current time
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        scheduler - the scheduler used as the time source
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: SkipLast
        +
        +
        • +
      + + + +
        +
      • +

        skipLast

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> skipLast(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean delayError)
        +
        Returns an Observable that drops items emitted by the current Observable during a specified time window + (defined on a specified scheduler) before the source completes. +

        + +

        + Note: this action will cache the latest items arriving in the specified time window. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use to track the current time
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        scheduler - the scheduler used as the time source
        +
        delayError - if true, an exception signaled by the current Observable is delayed until the regular elements are consumed + by the downstream; if false, an exception is immediately signaled and all regular elements dropped
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: SkipLast
        +
        +
        • +
      + + + +
        +
      • +

        skipLast

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> skipLast(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean delayError,
+        int bufferSize)
        +
        Returns an Observable that drops items emitted by the current Observable during a specified time window + (defined on a specified scheduler) before the source completes. +

        + +

        + Note: this action will cache the latest items arriving in the specified time window. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        scheduler - the scheduler used as the time source
        +
        delayError - if true, an exception signaled by the current Observable is delayed until the regular elements are consumed + by the downstream; if false, an exception is immediately signaled and all regular elements dropped
        +
        bufferSize - the hint about how many elements to expect to be skipped
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: SkipLast
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        sorted

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> sorted()
        +
        Returns an Observable that emits the events emitted by the current Observable, in a + sorted order. Each item emitted by the current Observable must implement Comparable with respect to all + other items in the sequence. +

        + +

        + If any item emitted by the current Observable does not implement Comparable with respect to + all other items emitted by the current Observable, no items will be emitted and the + sequence is terminated with a ClassCastException. + +

        Note that calling sorted with long, non-terminating or infinite sources + might cause OutOfMemoryError + +

        +
        Scheduler:
        +
        sorted does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Observable instance
        +
        +
        • +
      + + + +
        +
      • +

        sorted

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> sorted(@NonNull Comparator<? super T> comparator)
        +
        Returns an Observable that emits the events emitted by the current Observable, in a + sorted order based on a specified comparison function. + +

        Note that calling sorted with long, non-terminating or infinite sources + might cause OutOfMemoryError + +

        +
        Scheduler:
        +
        sorted does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        comparator - a function that compares two items emitted by the current Observable and returns an int + that indicates their sort order
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if comparator is null
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        subscribe

        +
        @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Disposable subscribe(@NonNull Consumer<? super T> onNext,
+        @NonNull Consumer<? super Throwable> onError,
+        @NonNull Action onComplete,
+        @NonNull DisposableContainer container)
        +
        Wraps the given onXXX callbacks into a Disposable Observer, + adds it to the given DisposableContainer and ensures, that if the upstream + terminates or this particular Disposable is disposed, the Observer is removed + from the given container. +

        + The Observer will be removed after the callback for the terminal event has been invoked. +

        +
        Scheduler:
        +
        subscribe does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        onNext - the callback for upstream items
        +
        onError - the callback for an upstream error if any
        +
        onComplete - the callback for the upstream completion if any
        +
        container - the DisposableContainer (such as CompositeDisposable) to add and remove the + created Disposable Observer
        +
        Returns:
        +
        the Disposable that allows disposing the particular subscription.
        +
        Throws:
        +
        NullPointerException - if onNext, onError, + onComplete or container is null
        +
        Since:
        +
        3.1.0
        +
        +
        • +
      + + + + + + + +
        +
      • +

        subscribeActual

        +
        protected abstract void subscribeActual(@NonNull Observer<? super T> observer)
        +
        Operator implementations (both source and intermediate) should implement this method that + performs the necessary business logic and handles the incoming Observers. +

        There is no need to call any of the plugin hooks on the current Observable instance or + the Observer; all hooks and basic safeguards have been + applied by subscribe(Observer) before this method gets called.

        +
        +
        Parameters:
        +
        observer - the incoming Observer, never null
        +
        +
        • +
      + + + + + +
        +
      • +

        subscribeWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <E extends Observer<? super T>> E subscribeWith(E observer)
        +
        Subscribes a given Observer (subclass) to the current Observable and returns the given + Observer instance as is. +

        Usage example: + 

        
+ Observable<Integer> source = Observable.range(1, 10);
+ CompositeDisposable composite = new CompositeDisposable();
+
+ DisposableObserver<Integer> ds = new DisposableObserver<>() {
+     // ...
+ };
+
+ composite.add(source.subscribeWith(ds));
+
        +
        +
        Scheduler:
        +
        subscribeWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        E - the type of the Observer to use and return
        +
        Parameters:
        +
        observer - the Observer (subclass) to use and return, not null
        +
        Returns:
        +
        the input observer
        +
        Throws:
        +
        NullPointerException - if observer is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        switchMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> switchMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper)
        +
        Returns a new Observable by applying a function that you supply to each item emitted by the current + Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted + of these ObservableSources. +

        + The resulting Observable completes if both the current Observable and the last inner ObservableSource, if any, complete. + If the current Observable signals an onError, the inner ObservableSource is disposed and the error delivered in-sequence. +

        + +

        +
        Scheduler:
        +
        switchMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the inner ObservableSources and the output
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Observable, returns an + ObservableSource
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap, +switchMapDelayError(Function)
        +
        +
        • +
      + + + +
        +
      • +

        switchMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> switchMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
+        int bufferSize)
        +
        Returns a new Observable by applying a function that you supply to each item emitted by the current + Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted + of these ObservableSources. +

        + The resulting Observable completes if both the current Observable and the last inner ObservableSource, if any, complete. + If the current Observable signals an onError, the inner ObservableSource is disposed and the error delivered in-sequence. +

        + +

        +
        Scheduler:
        +
        switchMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the inner ObservableSources and the output
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Observable, returns an + ObservableSource
        +
        bufferSize - the number of elements expected from the current active inner ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap, +switchMapDelayError(Function, int)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapCompletable

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Completable switchMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper)
        +
        Maps the items of the current Observable into CompletableSources, subscribes to the newer one while + disposing the subscription to the previous CompletableSource, thus keeping at most one + active CompletableSource running. +

        + +

        + Since a CompletableSource doesn't produce any items, the resulting reactive type of + this operator is a Completable that can only indicate successful completion or + a failure in any of the inner CompletableSources or the failure of the current + Observable. +

        +
        Scheduler:
        +
        switchMapCompletable does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If either the current Observable or the active CompletableSource signals an onError, + the resulting Completable is terminated immediately with that Throwable. + Use the switchMapCompletableDelayError(Function) to delay such inner failures until + every inner CompletableSources and the main Observable terminates in some fashion. + If they fail concurrently, the operator may combine the Throwables into a + CompositeException + and signal it to the downstream instead. If any inactivated (switched out) CompletableSource + signals an onError late, the Throwables will be signaled to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. +
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Parameters:
        +
        mapper - the function called with each upstream item and should return a + CompletableSource to be subscribed to and awaited for + (non blockingly) for its terminal event
        +
        Returns:
        +
        the new Completable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        switchMapCompletableDelayError(Function)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapCompletableDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Completable switchMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper)
        +
        Maps the upstream values into CompletableSources, subscribes to the newer one while + disposing the subscription to the previous CompletableSource, thus keeping at most one + active CompletableSource running and delaying any main or inner errors until all + of them terminate. +

        + +

        + Since a CompletableSource doesn't produce any items, the resulting reactive type of + this operator is a Completable that can only indicate successful completion or + a failure in any of the inner CompletableSources or the failure of the current + Observable. +

        +
        Scheduler:
        +
        switchMapCompletableDelayError does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        The errors of the current Observable and all the CompletableSources, who had the chance + to run to their completion, are delayed until + all of them terminate in some fashion. At this point, if there was only one failure, the respective + Throwable is emitted to the downstream. It there were more than one failures, the + operator combines all Throwables into a CompositeException + and signals that to the downstream. + If any inactivated (switched out) CompletableSource + signals an onError late, the Throwables will be signaled to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. +
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Parameters:
        +
        mapper - the function called with each upstream item and should return a + CompletableSource to be subscribed to and awaited for + (non blockingly) for its terminal event
        +
        Returns:
        +
        the new Completable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        switchMapCompletable(Function)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapMaybe

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> switchMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)
        +
        Maps the items of the current Observable into MaybeSources and switches (subscribes) to the newer ones + while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if + available while failing immediately if the current Observable or any of the + active inner MaybeSources fail. +

        + +

        +
        Scheduler:
        +
        switchMapMaybe does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        This operator terminates with an onError if the current Observable or any of + the inner MaybeSources fail while they are active. When this happens concurrently, their + individual Throwable errors may get combined and emitted as a single + CompositeException. Otherwise, a late + (i.e., inactive or switched out) onError from the current Observable or from any of + the inner MaybeSources will be forwarded to the global error handler via + RxJavaPlugins.onError(Throwable) as + UndeliverableException
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        mapper - the function called with the current upstream event and should + return a MaybeSource to replace the current active inner source + and get subscribed to.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        switchMapMaybeDelayError(Function)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapMaybeDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> switchMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)
        +
        Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones + while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if + available, delaying errors from the current Observable or the inner MaybeSources until all terminate. +

        + +

        +
        Scheduler:
        +
        switchMapMaybeDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.11 - experimental

        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        mapper - the function called with the current upstream event and should + return a MaybeSource to replace the current active inner source + and get subscribed to.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        switchMapMaybe(Function)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapSingle

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> switchMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)
        +
        Returns a new Observable by applying a function that you supply to each item emitted by the current + Observable that returns a SingleSource, and then emitting the item emitted by the most recently emitted + of these SingleSources. +

        + The resulting Observable completes if both the current Observable and the last inner SingleSource, if any, complete. + If the current Observable signals an onError, the inner SingleSource is disposed and the error delivered in-sequence. +

        + +

        +
        Scheduler:
        +
        switchMapSingle does not operate by default on a particular Scheduler.
        +
        +

        History: 2.0.8 - experimental

        +
        +
        Type Parameters:
        +
        R - the element type of the inner SingleSources and the output
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Observable, returns a + SingleSource
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap, +switchMapSingleDelayError(Function)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapSingleDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> switchMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)
        +
        Returns a new Observable by applying a function that you supply to each item emitted by the current + Observable that returns a SingleSource, and then emitting the item emitted by the most recently emitted + of these SingleSources and delays any error until all SingleSources terminate. +

        + The resulting Observable completes if both the current Observable and the last inner SingleSource, if any, complete. + If the current Observable signals an onError, the termination of the last inner SingleSource will emit that error as is + or wrapped into a CompositeException along with the other possible errors the former inner SingleSources signaled. +

        + +

        +
        Scheduler:
        +
        switchMapSingleDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.0.8 - experimental

        +
        +
        Type Parameters:
        +
        R - the element type of the inner SingleSources and the output
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Observable, returns a + SingleSource
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap, +switchMapSingle(Function)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> switchMapDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper)
        +
        Returns a new Observable by applying a function that you supply to each item emitted by the current + Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted + of these ObservableSources and delays any error until all ObservableSources terminate. +

        + The resulting Observable completes if both the current Observable and the last inner ObservableSource, if any, complete. + If the current Observable signals an onError, the termination of the last inner ObservableSource will emit that error as is + or wrapped into a CompositeException along with the other possible errors the former inner ObservableSources signaled. +

        + +

        +
        Scheduler:
        +
        switchMapDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the inner ObservableSources and the output
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Observable, returns an + ObservableSource
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap, +switchMap(Function)
        +
        +
        • +
      + + + +
        +
      • +

        switchMapDelayError

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> switchMapDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
+        int bufferSize)
        +
        Returns a new Observable by applying a function that you supply to each item emitted by the current + Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted + of these ObservableSources and delays any error until all ObservableSources terminate. +

        + The resulting Observable completes if both the current Observable and the last inner ObservableSource, if any, complete. + If the current Observable signals an onError, the termination of the last inner ObservableSource will emit that error as is + or wrapped into a CompositeException along with the other possible errors the former inner ObservableSources signaled. +

        + +

        +
        Scheduler:
        +
        switchMapDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the inner ObservableSources and the output
        +
        Parameters:
        +
        mapper - a function that, when applied to an item emitted by the current Observable, returns an + ObservableSource
        +
        bufferSize - the number of elements expected from the current active inner ObservableSource to be buffered
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap, +switchMap(Function, int)
        +
        +
        • +
      + + + +
        +
      • +

        take

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> take(long count)
        +
        Returns an Observable that emits only the first count items emitted by the current Observable. + If the source emits fewer than count items then all of its items are emitted. +

        + +

        + This method returns an Observable that will invoke a subscribing Observer's + onNext function a maximum of count times before invoking + onComplete. +

        + Taking 0 items from the current Observable will still subscribe to it, allowing the + subscription-time side-effects to happen there, but will be immediately disposed and the downstream completed + without any item emission. +

        +
        Scheduler:
        +
        This version of take does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - the maximum number of items to emit
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        IllegalArgumentException - if count is negative
        +
        See Also:
        +
        ReactiveX operators documentation: Take
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        takeLast

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> takeLast(int count)
        +
        Returns an Observable that emits at most the last count items emitted by the current Observable. + If the source emits fewer than count items then all of its items are emitted. +

        + +

        +
        Scheduler:
        +
        This version of takeLast does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - the maximum number of items to emit from the end of the sequence of items emitted by the current + Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        IllegalArgumentException - if count is negative
        +
        See Also:
        +
        ReactiveX operators documentation: TakeLast
        +
        +
        • +
      + + + + + + + +
        +
      • +

        takeLast

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> takeLast(long count,
+        long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns an Observable that emits at most a specified number of items from the current Observable that were + emitted in a specified window of time before the current Observable completed, where the timing information is + provided by a given Scheduler. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use for tracking the current time
        +
        +
        +
        Parameters:
        +
        count - the maximum number of items to emit
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that provides the timestamps for the observed items
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if count is negative
        +
        See Also:
        +
        ReactiveX operators documentation: TakeLast
        +
        +
        • +
      + + + +
        +
      • +

        takeLast

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> takeLast(long count,
+        long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean delayError,
+        int bufferSize)
        +
        Returns an Observable that emits at most a specified number of items from the current Observable that were + emitted in a specified window of time before the current Observable completed, where the timing information is + provided by a given Scheduler. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use for tracking the current time
        +
        +
        +
        Parameters:
        +
        count - the maximum number of items to emit
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that provides the timestamps for the observed items
        +
        delayError - if true, an exception signaled by the current Observable is delayed until the regular elements are consumed + by the downstream; if false, an exception is immediately signaled and all regular elements dropped
        +
        bufferSize - the hint about how many elements to expect to be last
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if count is negative or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: TakeLast
        +
        +
        • +
      + + + + + + + +
        +
      • +

        takeLast

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:trampoline")
+ @NonNull
+public final @NonNull Observable<T> takeLast(long time,
+        @NonNull TimeUnit unit,
+        boolean delayError)
        +
        Returns an Observable that emits the items from the current Observable that were emitted in a specified + window of time before the current Observable completed. +

        + +

        +
        Scheduler:
        +
        takeLast does not operate on any particular scheduler but uses the current time + from the trampoline Scheduler.
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        delayError - if true, an exception signaled by the current Observable is delayed until the regular elements are consumed + by the downstream; if false, an exception is immediately signaled and all regular elements dropped
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: TakeLast
        +
        +
        • +
      + + + + + + + +
        +
      • +

        takeLast

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> takeLast(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean delayError)
        +
        Returns an Observable that emits the items from the current Observable that were emitted in a specified + window of time before the current Observable completed, where the timing information is provided by a specified + Scheduler. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that provides the timestamps for the observed items
        +
        delayError - if true, an exception signaled by the current Observable is delayed until the regular elements are consumed + by the downstream; if false, an exception is immediately signaled and all regular elements dropped
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: TakeLast
        +
        +
        • +
      + + + +
        +
      • +

        takeLast

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> takeLast(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean delayError,
+        int bufferSize)
        +
        Returns an Observable that emits the items from the current Observable that were emitted in a specified + window of time before the current Observable completed, where the timing information is provided by a specified + Scheduler. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        time - the length of the time window
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that provides the timestamps for the observed items
        +
        delayError - if true, an exception signaled by the current Observable is delayed until the regular elements are consumed + by the downstream; if false, an exception is immediately signaled and all regular elements dropped
        +
        bufferSize - the hint about how many elements to expect to be last
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: TakeLast
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        throttleFirst

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> throttleFirst(long skipDuration,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        @NonNull Consumer<? super T> onDropped)
        +
        Returns an Observable that emits only the first item emitted by the current Observable during sequential + time windows of a specified duration, where the windows are managed by a specified Scheduler. +

        + This differs from throttleLast(long, java.util.concurrent.TimeUnit) in that this only tracks passage of time whereas + throttleLast ticks at scheduled intervals. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        skipDuration - time to wait before emitting another item after emitting the last item
        +
        unit - the unit of time of skipDuration
        +
        scheduler - the Scheduler to use internally to manage the timers that handle timeout for each + event
        +
        onDropped - called when an item doesn't get delivered to the downstream
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler or onDropped is null
        +
        Since:
        +
        3.1.6 - Experimental
        +
        See Also:
        +
        ReactiveX operators documentation: Sample
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        throttleLatest

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Observable<T> throttleLatest(long timeout,
+        @NonNull TimeUnit unit)
        +
        Throttles items from the current Observable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them. +

        + +

        + Unlike the option with throttleLatest(long, TimeUnit, boolean), the very last item being held back + (if any) is not emitted when the upstream completes. +

        + If no items were emitted from the upstream during this timeout phase, the next + upstream item is emitted immediately and the timeout window starts from then. +

        +
        Scheduler:
        +
        throttleLatest operates by default on the computation Scheduler.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        timeout - the time to wait after an item emission towards the downstream + before trying to emit the latest item from upstream again
        +
        unit - the time unit
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        throttleLatest(long, TimeUnit, boolean), +throttleLatest(long, TimeUnit, Scheduler)
        +
        +
        • +
      + + + +
        +
      • +

        throttleLatest

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Observable<T> throttleLatest(long timeout,
+        @NonNull TimeUnit unit,
+        boolean emitLast)
        +
        Throttles items from the current Observable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them. +

        + +

        + If no items were emitted from the upstream during this timeout phase, the next + upstream item is emitted immediately and the timeout window starts from then. +

        +
        Scheduler:
        +
        throttleLatest operates by default on the computation Scheduler.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        timeout - the time to wait after an item emission towards the downstream + before trying to emit the latest item from upstream again
        +
        unit - the time unit
        +
        emitLast - If true, the very last item from the upstream will be emitted + immediately when the upstream completes, regardless if there is + a timeout window active or not. If false, the very last + upstream item is ignored and the flow terminates.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        throttleLatest(long, TimeUnit, Scheduler, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        throttleLatest

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> throttleLatest(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Throttles items from the current Observable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them. +

        + +

        + Unlike the option with throttleLatest(long, TimeUnit, Scheduler, boolean), the very last item being held back + (if any) is not emitted when the upstream completes. +

        + If no items were emitted from the upstream during this timeout phase, the next + upstream item is emitted immediately and the timeout window starts from then. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        timeout - the time to wait after an item emission towards the downstream + before trying to emit the latest item from upstream again
        +
        unit - the time unit
        +
        scheduler - the Scheduler where the timed wait and latest item + emission will be performed
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        throttleLatest(long, TimeUnit, Scheduler, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        throttleLatest

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> throttleLatest(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean emitLast)
        +
        Throttles items from the current Observable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them. +

        + +

        + If no items were emitted from the upstream during this timeout phase, the next + upstream item is emitted immediately and the timeout window starts from then. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        timeout - the time to wait after an item emission towards the downstream + before trying to emit the latest item from upstream again
        +
        unit - the time unit
        +
        scheduler - the Scheduler where the timed wait and latest item + emission will be performed
        +
        emitLast - If true, the very last item from the upstream will be emitted + immediately when the upstream completes, regardless if there is + a timeout window active or not. If false, the very last + upstream item is ignored and the flow terminates.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        throttleLatest

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> throttleLatest(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean emitLast,
+        @NonNull Consumer<? super T> onDropped)
        +
        Throttles items from the current Observable by first emitting the next + item from upstream, then periodically emitting the latest item (if any) when + the specified timeout elapses between them, invoking the consumer for any dropped item. +

        + +

        + If no items were emitted from the upstream during this timeout phase, the next + upstream item is emitted immediately and the timeout window starts from then. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        Error handling:
        +
        + If the upstream signals an onError or onDropped callback crashes, + the error is delivered immediately to the downstream. If both happen, a CompositeException + is created, containing both the upstream and the callback error. + If the onDropped callback crashes when the sequence gets disposed, the exception is forwarded + to the global error handler via RxJavaPlugins.onError(Throwable). +
        +
        +
        +
        Parameters:
        +
        timeout - the time to wait after an item emission towards the downstream + before trying to emit the latest item from upstream again
        +
        unit - the time unit
        +
        scheduler - the Scheduler where the timed wait and latest item + emission will be performed
        +
        emitLast - If true, the very last item from the upstream will be emitted + immediately when the upstream completes, regardless if there is + a timeout window active or not. If false, the very last + upstream item is ignored and the flow terminates.
        +
        onDropped - called when an item is replaced by a newer item that doesn't get delivered + to the downstream, including the very last item if emitLast is false + and the current undelivered item when the sequence gets disposed.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit, scheduler or onDropped is null
        +
        Since:
        +
        3.1.6 - Experimental
        +
        +
        • +
      + + + +
        +
      • +

        throttleWithTimeout

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Observable<T> throttleWithTimeout(long timeout,
+        @NonNull TimeUnit unit)
        +
        Returns an Observable that mirrors the current Observable, except that it drops items emitted by the + current Observable that are followed by newer items before a timeout value expires. The timer resets on + each emission (alias to debounce(long, TimeUnit, Scheduler)). +

        + Note: If items keep being emitted by the current Observable faster than the timeout then no items + will be emitted by the resulting Observable. +

        + +

        +
        Scheduler:
        +
        throttleWithTimeout operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timeout - the length of the window of time that must pass after the emission of an item from the current + Observable, in which the current Observable emits no items, in order for the item to be emitted by the + resulting Observable
        +
        unit - the unit of time for the specified timeout
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Debounce, +debounce(long, TimeUnit)
        +
        +
        • +
      + + + +
        +
      • +

        throttleWithTimeout

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> throttleWithTimeout(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns an Observable that mirrors the current Observable, except that it drops items emitted by the + current Observable that are followed by newer items before a timeout value expires on a specified + Scheduler. The timer resets on each emission (Alias to debounce(long, TimeUnit, Scheduler)). +

        + Note: If items keep being emitted by the current Observable faster than the timeout then no items + will be emitted by the resulting Observable. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timeout - the length of the window of time that must pass after the emission of an item from the current + Observable, in which the current Observable emits no items, in order for the item to be emitted by the + resulting Observable
        +
        unit - the unit of time for the specified timeout
        +
        scheduler - the Scheduler to use internally to manage the timers that handle the timeout for each + item
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Debounce, +debounce(long, TimeUnit, Scheduler)
        +
        +
        • +
      + + + +
        +
      • +

        throttleWithTimeout

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> throttleWithTimeout(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        @NonNull Consumer<? super T> onDropped)
        +
        Returns an Observable that mirrors the current Observable, except that it drops items emitted by the + current Observable that are followed by newer items before a timeout value expires on a specified + Scheduler. The timer resets on each emission (Alias to debounce(long, TimeUnit, Scheduler)). +

        + Note: If items keep being emitted by the current Observable faster than the timeout then no items + will be emitted by the resulting Observable. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timeout - the length of the window of time that must pass after the emission of an item from the current + Observable, in which the current Observable emits no items, in order for the item to be emitted by the + resulting Observable
        +
        unit - the unit of time for the specified timeout
        +
        scheduler - the Scheduler to use internally to manage the timers that handle the timeout for each + item
        +
        onDropped - called with the current entry when it has been replaced by a new one
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null or onDropped is null
        +
        Since:
        +
        3.1.6 - Experimental
        +
        See Also:
        +
        ReactiveX operators documentation: Debounce, +debounce(long, TimeUnit, Scheduler, Consumer)
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <V> @NonNull Observable<T> timeout(@NonNull Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator)
        +
        Returns an Observable that mirrors the current Observable, but notifies observers of a + TimeoutException if an item emitted by the current Observable doesn't arrive within a window of + time after the emission of the previous item, where that period of time is measured by an ObservableSource that + is a function of the previous item. +

        + +

        + Note: The arrival of the first source item is never timed out. +

        +
        Scheduler:
        +
        This version of timeout operates by default on the immediate Scheduler.
        +
        +
        +
        Type Parameters:
        +
        V - the timeout value type (ignored)
        +
        Parameters:
        +
        itemTimeoutIndicator - a function that returns an ObservableSource for each item emitted by the current + Observable and that determines the timeout window for the subsequent item
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if itemTimeoutIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <V> @NonNull Observable<T> timeout(@NonNull Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator,
+        @NonNull ObservableSource<? extends T> fallback)
        +
        Returns an Observable that mirrors the current Observable, but that switches to a fallback ObservableSource if + an item emitted by the current Observable doesn't arrive within a window of time after the emission of the + previous item, where that period of time is measured by an ObservableSource that is a function of the previous + item. +

        + +

        + Note: The arrival of the first source item is never timed out. +

        +
        Scheduler:
        +
        This version of timeout operates by default on the immediate Scheduler.
        +
        +
        +
        Type Parameters:
        +
        V - the timeout value type (ignored)
        +
        Parameters:
        +
        itemTimeoutIndicator - a function that returns an ObservableSource, for each item emitted by the current Observable, that + determines the timeout window for the subsequent item
        +
        fallback - the fallback ObservableSource to switch to if the current Observable times out
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if itemTimeoutIndicator or fallback is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Observable<T> timeout(long timeout,
+        @NonNull TimeUnit unit)
        +
        Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted + item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, + the resulting Observable terminates and notifies observers of a TimeoutException. +

        + +

        +
        Scheduler:
        +
        This version of timeout operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timeout - maximum duration between emitted items before a timeout occurs
        +
        unit - the unit of time that applies to the timeout argument.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Observable<T> timeout(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull ObservableSource<? extends T> fallback)
        +
        Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted + item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, + the current Observable is disposed and the resulting Observable begins instead + to mirror a fallback ObservableSource. +

        + +

        +
        Scheduler:
        +
        This version of timeout operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timeout - maximum duration between items before a timeout occurs
        +
        unit - the unit of time that applies to the timeout argument
        +
        fallback - the fallback ObservableSource to use in case of a timeout
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or fallback is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> timeout(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        @NonNull ObservableSource<? extends T> fallback)
        +
        Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted + item using a specified Scheduler. If the next item isn't emitted within the specified timeout duration + starting from its predecessor, the current Observable is disposed and returned Observable + begins instead to mirror a fallback ObservableSource. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timeout - maximum duration between items before a timeout occurs
        +
        unit - the unit of time that applies to the timeout argument
        +
        scheduler - the Scheduler to run the timeout timers on
        +
        fallback - the ObservableSource to use as the fallback in case of a timeout
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit, scheduler or fallback is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> timeout(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted + item, where this policy is governed on a specified Scheduler. If the next item isn't emitted within the + specified timeout duration starting from its predecessor, the resulting Observable terminates and + notifies observers of a TimeoutException. +

        + +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timeout - maximum duration between items before a timeout occurs
        +
        unit - the unit of time that applies to the timeout argument
        +
        scheduler - the Scheduler to run the timeout timers on
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,V> @NonNull Observable<T> timeout(@NonNull ObservableSource<U> firstTimeoutIndicator,
+        @NonNull Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator)
        +
        Returns an Observable that mirrors the current Observable, but notifies observers of a + TimeoutException if either the first item emitted by the current Observable or any subsequent item + doesn't arrive within time windows defined by indicator ObservableSources. +

        + +

        +
        Scheduler:
        +
        This version of timeout operates by default on the immediate Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the first timeout value type (ignored)
        +
        V - the subsequent timeout value type (ignored)
        +
        Parameters:
        +
        firstTimeoutIndicator - a function that returns an ObservableSource that determines the timeout window for the first source + item
        +
        itemTimeoutIndicator - a function that returns an ObservableSource for each item emitted by the current Observable and that + determines the timeout window in which the subsequent source item must arrive in order to + continue the sequence
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if firstTimeoutIndicator or itemTimeoutIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,V> @NonNull Observable<T> timeout(@NonNull ObservableSource<U> firstTimeoutIndicator,
+        @NonNull Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator,
+        @NonNull ObservableSource<? extends T> fallback)
        +
        Returns an Observable that mirrors the current Observable, but switches to a fallback ObservableSource if either + the first item emitted by the current Observable or any subsequent item doesn't arrive within time windows + defined by indicator ObservableSources. +

        + +

        +
        Scheduler:
        +
        This version of timeout operates by default on the immediate Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the first timeout value type (ignored)
        +
        V - the subsequent timeout value type (ignored)
        +
        Parameters:
        +
        firstTimeoutIndicator - a function that returns an ObservableSource which determines the timeout window for the first source + item
        +
        itemTimeoutIndicator - a function that returns an ObservableSource for each item emitted by the current Observable and that + determines the timeout window in which the subsequent source item must arrive in order to + continue the sequence
        +
        fallback - the fallback ObservableSource to switch to if the current Observable times out
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if firstTimeoutIndicator, itemTimeoutIndicator or fallback is null
        +
        See Also:
        +
        ReactiveX operators documentation: Timeout
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        to

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> R to(@NonNull ObservableConverter<T,? extends R> converter)
        +
        Calls the specified converter function during assembly time and returns its resulting value. +

        + This allows fluent conversion to any other type. +

        +
        Scheduler:
        +
        to does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.7 - experimental

        +
        +
        Type Parameters:
        +
        R - the resulting object type
        +
        Parameters:
        +
        converter - the function that receives the current Observable instance and returns a value
        +
        Returns:
        +
        the converted value
        +
        Throws:
        +
        NullPointerException - if converter is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        toList

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Single<List<T>> toList()
        +
        Returns a Single that emits a single item, a List composed of all the items emitted by the + current and finite Observable. +

        + +

        + Normally, an ObservableSource that returns multiple items will do so by invoking its Observer's + onNext method for each such item. You can change this behavior by having the + operator to compose a list of all of these items and then to invoke the SingleObserver's onSuccess + method once, passing it the entire list, by calling the Observable's toList method prior to + calling its subscribe() method. +

        + Note that this operator requires the upstream to signal onComplete for the accumulated list to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        toList does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Single instance
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toList

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Single<List<T>> toList(int capacityHint)
        +
        Returns a Single that emits a single item, a List composed of all the items emitted by the + current and finite Observable. +

        + +

        + Normally, an ObservableSource that returns multiple items will do so by invoking its Observer's + onNext method for each such item. You can change this behavior by having the + operator to compose a list of all of these items and then to invoke the SingleObserver's onSuccess + method once, passing it the entire list, by calling the Observable's toList method prior to + calling its subscribe() method. +

        + Note that this operator requires the upstream to signal onComplete for the accumulated list to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        toList does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        capacityHint - the number of elements expected from the current Observable
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toList

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U extends Collection<? super T>> @NonNull Single<U> toList(@NonNull Supplier<U> collectionSupplier)
        +
        Returns a Single that emits a single item, a Collection (subclass) composed of all the items emitted by the + finite upstream Observable. +

        + +

        + Normally, an ObservableSource that returns multiple items will do so by invoking its Observer's + onNext method for each such item. You can change this behavior by having the + operator to compose a collection of all of these items and then to invoke the SingleObserver's onSuccess + method once, passing it the entire collection, by calling the Observable's toList method prior to + calling its subscribe() method. +

        + Note that this operator requires the upstream to signal onComplete for the accumulated collection to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        toList does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the subclass of a collection of Ts
        +
        Parameters:
        +
        collectionSupplier - the Supplier returning the collection (for each individual Observer) to be filled in
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if collectionSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K> @NonNull Single<Map<K,T>> toMap(@NonNull Function<? super T,? extends K> keySelector)
        +
        Returns a Single that emits a single HashMap containing all items emitted by the + current and finite Observable, mapped by the keys returned by a specified + keySelector function. +

        + +

        + If more than one source item maps to the same key, the HashMap will contain the latest of those items. +

        + Note that this operator requires the upstream to signal onComplete for the accumulated HashMap to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        toMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type of the Map
        +
        Parameters:
        +
        keySelector - the function that extracts the key from a source item to be used in the HashMap
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if keySelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K,V> @NonNull Single<Map<K,V>> toMap(@NonNull Function<? super T,? extends K> keySelector,
+        @NonNull Function<? super T,? extends V> valueSelector)
        +
        Returns a Single that emits a single HashMap containing values corresponding to items emitted by the + current and finite Observable, mapped by the keys and values returned by the given selector functions. +

        + +

        + If more than one source item maps to the same key, the HashMap will contain a single entry that + corresponds to the latest of those items. +

        + Note that this operator requires the upstream to signal onComplete for the accumulated HashMap to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        toMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type of the HashMap
        +
        V - the value type of the HashMap
        +
        Parameters:
        +
        keySelector - the function that extracts the key from a source item to be used in the HashMap
        +
        valueSelector - the function that extracts the value from a source item to be used in the HashMap
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if keySelector or valueSelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toMap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K,V> @NonNull Single<Map<K,V>> toMap(@NonNull Function<? super T,? extends K> keySelector,
+        @NonNull Function<? super T,? extends V> valueSelector,
+        @NonNull Supplier<? extends Map<K,V>> mapSupplier)
        +
        Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that + contains keys and values extracted from the items, via selector functions, emitted by the current and finite Observable. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated Map to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        toMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type of the Map
        +
        V - the value type of the Map
        +
        Parameters:
        +
        keySelector - the function that extracts the key from a source item to be used in the Map
        +
        valueSelector - the function that extracts the value from the source items to be used as value in the Map
        +
        mapSupplier - the function that returns a Map instance to be used
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if keySelector, valueSelector or mapSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toMultimap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K> @NonNull Single<Map<K,Collection<T>>> toMultimap(@NonNull Function<? super T,? extends K> keySelector)
        +
        Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the + current and finite Observable keyed by a specified keySelector function. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated HashMap to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        toMultimap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type of the HashMap
        +
        Parameters:
        +
        keySelector - the function that extracts the key from the source items to be used as key in the HashMap
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if keySelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toMultimap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K,V> @NonNull Single<Map<K,Collection<V>>> toMultimap(@NonNull Function<? super T,? extends K> keySelector,
+        Function<? super T,? extends V> valueSelector)
        +
        Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a + specified valueSelector function from items emitted by the current and finite Observable, + keyed by a specified keySelector function. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated HashMap to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        toMultimap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type of the HashMap
        +
        V - the value type of the HashMap
        +
        Parameters:
        +
        keySelector - the function that extracts a key from the source items to be used as key in the HashMap
        +
        valueSelector - the function that extracts a value from the source items to be used as value in the HashMap
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if keySelector or valueSelector is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toMultimap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K,V> @NonNull Single<Map<K,Collection<V>>> toMultimap(@NonNull Function<? super T,? extends K> keySelector,
+        @NonNull Function<? super T,? extends V> valueSelector,
+        @NonNull Supplier<? extends Map<K,Collection<V>>> mapSupplier,
+        @NonNull Function<? super K,? extends Collection<? super V>> collectionFactory)
        +
        Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that + contains a custom Collection of values, extracted by a specified valueSelector function from + items emitted by the current and finite Observable, and keyed by the keySelector function. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated Map to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        toMultimap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type of the Map
        +
        V - the value type of the Map
        +
        Parameters:
        +
        keySelector - the function that extracts a key from the source items to be used as the key in the Map
        +
        valueSelector - the function that extracts a value from the source items to be used as the value in the Map
        +
        mapSupplier - the function that returns a Map instance to be used
        +
        collectionFactory - the function that returns a Collection instance for a particular key to be used in the Map
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if keySelector, valueSelector, mapSupplier or collectionFactory is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toMultimap

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <K,V> @NonNull Single<Map<K,Collection<V>>> toMultimap(@NonNull Function<? super T,? extends K> keySelector,
+        @NonNull Function<? super T,? extends V> valueSelector,
+        @NonNull Supplier<Map<K,Collection<V>>> mapSupplier)
        +
        Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that + contains an ArrayList of values, extracted by a specified valueSelector function from items + emitted by the current and finite Observable and keyed by the keySelector function. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated Map to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        toMultimap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        K - the key type of the Map
        +
        V - the value type of the Map
        +
        Parameters:
        +
        keySelector - the function that extracts a key from the source items to be used as the key in the Map
        +
        valueSelector - the function that extracts a value from the source items to be used as the value in the Map
        +
        mapSupplier - the function that returns a Map instance to be used
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if keySelector, valueSelector or mapSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + + + + + +
        +
      • +

        toSortedList

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Single<List<T>> toSortedList()
        +
        Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a + sorted order. Each item emitted by the current Observable must implement Comparable with respect to all + other items in the sequence. + +

        + If any item emitted by the current Observable does not implement Comparable with respect to + all other items emitted by the current Observable, no items will be emitted and the + sequence is terminated with a ClassCastException. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated List to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        toSortedList does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Single instance
        +
        See Also:
        +
        ReactiveX operators documentation: To, +toSortedList(int), +toSortedList(Comparator)
        +
        +
        • +
      + + + +
        +
      • +

        toSortedList

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Single<List<T>> toSortedList(@NonNull Comparator<? super T> comparator)
        +
        Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a + sorted order based on a specified comparison function. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated List to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        toSortedList does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        comparator - a function that compares two items emitted by the current Observable and returns an int + that indicates their sort order
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if comparator is null
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toSortedList

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Single<List<T>> toSortedList(@NonNull Comparator<? super T> comparator,
+        int capacityHint)
        +
        Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a + sorted order based on a specified comparison function. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated List to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        toSortedList does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        comparator - a function that compares two items emitted by the current Observable and returns an int + that indicates their sort order
        +
        capacityHint - the initial capacity of the List used to accumulate items before sorting
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if comparator is null
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: To
        +
        +
        • +
      + + + +
        +
      • +

        toSortedList

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Single<List<T>> toSortedList(int capacityHint)
        +
        Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a + sorted order. Each item emitted by the current Observable must implement Comparable with respect to all + other items in the sequence. +

        + If any item emitted by the current Observable does not implement Comparable with respect to + all other items emitted by the current Observable, no items will be emitted and the + sequence is terminated with a ClassCastException. +

        + +

        + Note that this operator requires the upstream to signal onComplete for the accumulated List to + be emitted. Sources that are infinite and never complete will never emit anything through this + operator and an infinite source may lead to a fatal OutOfMemoryError. +

        +
        Scheduler:
        +
        toSortedList does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        capacityHint - the initial capacity of the List used to accumulate items before sorting
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: To, +toSortedList(Comparator, int)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<Observable<T>> window(long count)
        +
        Returns an Observable that emits windows of items it collects from the current Observable. The resulting + Observable emits connected, non-overlapping windows, each containing count items. When the current + Observable completes or encounters an error, the resulting Observable emits the current window and + propagates the notification from the current Observable. +

        + +

        +
        Scheduler:
        +
        This version of window does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - the maximum size of each window before it should be emitted
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<Observable<T>> window(long count,
+        long skip)
        +
        Returns an Observable that emits windows of items it collects from the current Observable. The resulting + Observable emits windows every skip items, each containing no more than count items. When + the current Observable completes or encounters an error, the resulting Observable emits the current window + and propagates the notification from the current Observable. +

        + +

        +
        Scheduler:
        +
        This version of window does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - the maximum size of each window before it should be emitted
        +
        skip - how many items need to be skipped before starting a new window. Note that if skip and + count are equal this is the same operation as window(long).
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        IllegalArgumentException - if count or skip is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<Observable<T>> window(long count,
+        long skip,
+        int bufferSize)
        +
        Returns an Observable that emits windows of items it collects from the current Observable. The resulting + Observable emits windows every skip items, each containing no more than count items. When + the current Observable completes or encounters an error, the resulting Observable emits the current window + and propagates the notification from the current Observable. +

        + +

        +
        Scheduler:
        +
        This version of window does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        count - the maximum size of each window before it should be emitted
        +
        skip - how many items need to be skipped before starting a new window. Note that if skip and + count are equal this is the same operation as window(long).
        +
        bufferSize - the capacity hint for the buffer in the inner windows
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        IllegalArgumentException - if count, skip or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Observable<Observable<T>> window(long timespan,
+        long timeskip,
+        @NonNull TimeUnit unit)
        +
        Returns an Observable that emits windows of items it collects from the current Observable. The resulting + Observable starts a new window periodically, as determined by the timeskip argument. It emits + each window after a fixed timespan, specified by the timespan argument. When the current + Observable completes or encounters an error, the resulting Observable emits the + current window and propagates the notification from the current Observable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Scheduler:
        +
        This version of window operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted
        +
        timeskip - the period of time after which a new window will be created
        +
        unit - the unit of time that applies to the timespan and timeskip arguments
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        IllegalArgumentException - if timespan or timeskip is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<Observable<T>> window(long timespan,
+        long timeskip,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns an Observable that emits windows of items it collects from the current Observable. The resulting + Observable starts a new window periodically, as determined by the timeskip argument. It emits + each window after a fixed timespan, specified by the timespan argument. When the current + Observable completes or encounters an error, the resulting Observable emits the + current window and propagates the notification from the current Observable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted
        +
        timeskip - the period of time after which a new window will be created
        +
        unit - the unit of time that applies to the timespan and timeskip arguments
        +
        scheduler - the Scheduler to use when determining the end and start of a window
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if timespan or timeskip is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<Observable<T>> window(long timespan,
+        long timeskip,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        int bufferSize)
        +
        Returns an Observable that emits windows of items it collects from the current Observable. The resulting + Observable starts a new window periodically, as determined by the timeskip argument. It emits + each window after a fixed timespan, specified by the timespan argument. When the current + Observable completes or encounters an error, the resulting Observable emits the + current window and propagates the notification from the current Observable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted
        +
        timeskip - the period of time after which a new window will be created
        +
        unit - the unit of time that applies to the timespan and timeskip arguments
        +
        scheduler - the Scheduler to use when determining the end and start of a window
        +
        bufferSize - the capacity hint for the buffer in the inner windows
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if timespan, timeskip or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Observable<Observable<T>> window(long timespan,
+        @NonNull TimeUnit unit)
        +
        Returns an Observable that emits windows of items it collects from the current Observable. The resulting + Observable emits connected, non-overlapping windows, each of a fixed duration specified by the + timespan argument. When the current Observable completes or encounters an error, the resulting + Observable emits the current window and propagates the notification from the current Observable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Scheduler:
        +
        This version of window operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted and replaced with a + new window
        +
        unit - the unit of time that applies to the timespan argument
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Observable<Observable<T>> window(long timespan,
+        @NonNull TimeUnit unit,
+        long count)
        +
        Returns an Observable that emits windows of items it collects from the current Observable. The resulting + Observable emits connected, non-overlapping windows, each of a fixed duration as specified by the + timespan argument or a maximum size as specified by the count argument (whichever is + reached first). When the current Observable completes or encounters an error, the resulting Observable + emits the current window and propagates the notification from the current Observable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Scheduler:
        +
        This version of window operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted and replaced with a + new window
        +
        unit - the unit of time that applies to the timespan argument
        +
        count - the maximum size of each window before it should be emitted
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Observable<Observable<T>> window(long timespan,
+        @NonNull TimeUnit unit,
+        long count,
+        boolean restart)
        +
        Returns an Observable that emits windows of items it collects from the current Observable. The resulting + Observable emits connected, non-overlapping windows, each of a fixed duration as specified by the + timespan argument or a maximum size as specified by the count argument (whichever is + reached first). When the current Observable completes or encounters an error, the resulting Observable + emits the current window and propagates the notification from the current Observable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Scheduler:
        +
        This version of window operates by default on the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted and replaced with a + new window
        +
        unit - the unit of time that applies to the timespan argument
        +
        count - the maximum size of each window before it should be emitted
        +
        restart - if true, when a window reaches the capacity limit, the timer is restarted as well
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<Observable<T>> window(long timespan,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Returns an Observable that emits windows of items it collects from the current Observable. The resulting + Observable emits connected, non-overlapping windows, each of a fixed duration as specified by the + timespan argument. When the current Observable completes or encounters an error, the resulting + Observable emits the current window and propagates the notification from the current Observable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted and replaced with a + new window
        +
        unit - the unit of time which applies to the timespan argument
        +
        scheduler - the Scheduler to use when determining the end and start of a window
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<Observable<T>> window(long timespan,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        long count)
        +
        Returns an Observable that emits windows of items it collects from the current Observable. The resulting + Observable emits connected, non-overlapping windows, each of a fixed duration specified by the + timespan argument or a maximum size specified by the count argument (whichever is reached + first). When the current Observable completes or encounters an error, the resulting Observable emits the + current window and propagates the notification from the current Observable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted and replaced with a + new window
        +
        unit - the unit of time which applies to the timespan argument
        +
        count - the maximum size of each window before it should be emitted
        +
        scheduler - the Scheduler to use when determining the end and start of a window
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<Observable<T>> window(long timespan,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        long count,
+        boolean restart)
        +
        Returns an Observable that emits windows of items it collects from the current Observable. The resulting + Observable emits connected, non-overlapping windows, each of a fixed duration specified by the + timespan argument or a maximum size specified by the count argument (whichever is reached + first). When the current Observable completes or encounters an error, the resulting Observable emits the + current window and propagates the notification from the current Observable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted and replaced with a + new window
        +
        unit - the unit of time which applies to the timespan argument
        +
        count - the maximum size of each window before it should be emitted
        +
        scheduler - the Scheduler to use when determining the end and start of a window
        +
        restart - if true, when a window reaches the capacity limit, the timer is restarted as well
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if count is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<Observable<T>> window(long timespan,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        long count,
+        boolean restart,
+        int bufferSize)
        +
        Returns an Observable that emits windows of items it collects from the current Observable. The resulting + Observable emits connected, non-overlapping windows, each of a fixed duration specified by the + timespan argument or a maximum size specified by the count argument (whichever is reached + first). When the current Observable completes or encounters an error, the resulting Observable emits the + current window and propagates the notification from the current Observable. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Scheduler:
        +
        You specify which Scheduler this operator will use.
        +
        +
        +
        Parameters:
        +
        timespan - the period of time each window collects items before it should be emitted and replaced with a + new window
        +
        unit - the unit of time which applies to the timespan argument
        +
        count - the maximum size of each window before it should be emitted
        +
        scheduler - the Scheduler to use when determining the end and start of a window
        +
        restart - if true, when a window reaches the capacity limit, the timer is restarted as well
        +
        bufferSize - the capacity hint for the buffer in the inner windows
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if count or bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <B> @NonNull Observable<Observable<T>> window(@NonNull ObservableSource<B> boundaryIndicator)
        +
        Returns an Observable that emits non-overlapping windows of items it collects from the current Observable + where the boundary of each window is determined by the items emitted from a specified boundary-governing + ObservableSource. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Scheduler:
        +
        This version of window does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        B - the window element type (ignored)
        +
        Parameters:
        +
        boundaryIndicator - an ObservableSource whose emitted items close and open windows
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if boundaryIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <B> @NonNull Observable<Observable<T>> window(@NonNull ObservableSource<B> boundaryIndicator,
+        int bufferSize)
        +
        Returns an Observable that emits non-overlapping windows of items it collects from the current Observable + where the boundary of each window is determined by the items emitted from a specified boundary-governing + ObservableSource. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Scheduler:
        +
        This version of window does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        B - the window element type (ignored)
        +
        Parameters:
        +
        boundaryIndicator - an ObservableSource whose emitted items close and open windows
        +
        bufferSize - the capacity hint for the buffer in the inner windows
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if boundaryIndicator is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,V> @NonNull Observable<Observable<T>> window(@NonNull ObservableSource<U> openingIndicator,
+        @NonNull Function<? super U,? extends ObservableSource<V>> closingIndicator)
        +
        Returns an Observable that emits windows of items it collects from the current Observable. The resulting + Observable emits windows that contain those items emitted by the current Observable between the time when + the openingIndicator ObservableSource emits an item and when the ObservableSource returned by + closingIndicator emits an item. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Scheduler:
        +
        This version of window does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the element type of the window-opening ObservableSource
        +
        V - the element type of the window-closing ObservableSources
        +
        Parameters:
        +
        openingIndicator - an ObservableSource that, when it emits an item, causes another window to be created
        +
        closingIndicator - a Function that produces an ObservableSource for every window created. When this indicator ObservableSource + emits an item, the associated window is completed
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if openingIndicator or closingIndicator is null
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        window

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,V> @NonNull Observable<Observable<T>> window(@NonNull ObservableSource<U> openingIndicator,
+        @NonNull Function<? super U,? extends ObservableSource<V>> closingIndicator,
+        int bufferSize)
        +
        Returns an Observable that emits windows of items it collects from the current Observable. The resulting + Observable emits windows that contain those items emitted by the current Observable between the time when + the openingIndicator ObservableSource emits an item and when the ObservableSource returned by + closingIndicator emits an item. +

        + +

        + Note that ignoring windows or subscribing later (i.e., on another thread) will result in + so-called window abandonment where a window may not contain any elements. In this case, subsequent + elements will be dropped until the condition for the next window boundary is satisfied. The behavior is + a trade-off for ensuring upstream cancellation can happen under some race conditions. +

        +
        Scheduler:
        +
        This version of window does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the element type of the window-opening ObservableSource
        +
        V - the element type of the window-closing ObservableSources
        +
        Parameters:
        +
        openingIndicator - an ObservableSource that, when it emits an item, causes another window to be created
        +
        closingIndicator - a Function that produces an ObservableSource for every window created. When this indicator ObservableSource + emits an item, the associated window is completed
        +
        bufferSize - the capacity hint for the buffer in the inner windows
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if openingIndicator or closingIndicator is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        See Also:
        +
        ReactiveX operators documentation: Window
        +
        +
        • +
      + + + +
        +
      • +

        withLatestFrom

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Observable<R> withLatestFrom(@NonNull ObservableSource<? extends U> other,
+        @NonNull BiFunction<? super T,? super U,? extends R> combiner)
        +
        Merges the specified ObservableSource into the current Observable sequence by using the resultSelector + function only when the current Observable emits an item. + +

        Note that this operator doesn't emit anything until the other source has produced at + least one value. The resulting emission only happens when the current Observable emits (and + not when the other source emits, unlike combineLatest). + If the other source doesn't produce any value and just completes, the sequence is completed immediately. + If the upstream completes before the other source has produced at least one value, the sequence completes + without emission. +

        + + +

        +
        Scheduler:
        +
        This operator, by default, doesn't run any particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the element type of the other ObservableSource
        +
        R - the result type of the combination
        +
        Parameters:
        +
        other - the other ObservableSource
        +
        combiner - the function to call when the current Observable emits an item and the other ObservableSource has already + emitted an item, to generate the item to be emitted by the resulting Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if other or combiner is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: CombineLatest
        +
        +
        • +
      + + + +
        +
      • +

        withLatestFrom

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <T1,T2,R> @NonNull Observable<R> withLatestFrom(@NonNull ObservableSource<T1> source1,
+        @NonNull ObservableSource<T2> source2,
+        @NonNull Function3<? super T,? super T1,? super T2,R> combiner)
        +
        Combines the value emission from the current Observable with the latest emissions from the + other ObservableSources via a function to produce the output item. + +

        Note that this operator doesn't emit anything until all other sources have produced at + least one value. The resulting emission only happens when the current Observable emits (and + not when any of the other sources emit, unlike combineLatest). + If a source doesn't produce any value and just completes, the sequence is completed immediately. + If the upstream completes before all other sources have produced at least one value, the sequence completes + without emission. +

        + +

        +
        Scheduler:
        +
        This operator does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the first other source's value type
        +
        T2 - the second other source's value type
        +
        R - the result value type
        +
        Parameters:
        +
        source1 - the first other ObservableSource
        +
        source2 - the second other ObservableSource
        +
        combiner - the function called with an array of values from each participating ObservableSource
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2 or combiner is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        withLatestFrom

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <T1,T2,T3,R> @NonNull Observable<R> withLatestFrom(@NonNull ObservableSource<T1> source1,
+        @NonNull ObservableSource<T2> source2,
+        @NonNull ObservableSource<T3> source3,
+        @NonNull Function4<? super T,? super T1,? super T2,? super T3,R> combiner)
        +
        Combines the value emission from the current Observable with the latest emissions from the + other ObservableSources via a function to produce the output item. + +

        Note that this operator doesn't emit anything until all other sources have produced at + least one value. The resulting emission only happens when the current Observable emits (and + not when any of the other sources emit, unlike combineLatest). + If a source doesn't produce any value and just completes, the sequence is completed immediately. + If the upstream completes before all other sources have produced at least one value, the sequence completes + without emission. +

        + +

        +
        Scheduler:
        +
        This operator does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the first other source's value type
        +
        T2 - the second other source's value type
        +
        T3 - the third other source's value type
        +
        R - the result value type
        +
        Parameters:
        +
        source1 - the first other ObservableSource
        +
        source2 - the second other ObservableSource
        +
        source3 - the third other ObservableSource
        +
        combiner - the function called with an array of values from each participating ObservableSource
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3 or combiner is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        withLatestFrom

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <T1,T2,T3,T4,R> @NonNull Observable<R> withLatestFrom(@NonNull ObservableSource<T1> source1,
+        @NonNull ObservableSource<T2> source2,
+        @NonNull ObservableSource<T3> source3,
+        @NonNull ObservableSource<T4> source4,
+        @NonNull Function5<? super T,? super T1,? super T2,? super T3,? super T4,R> combiner)
        +
        Combines the value emission from the current Observable with the latest emissions from the + other ObservableSources via a function to produce the output item. + +

        Note that this operator doesn't emit anything until all other sources have produced at + least one value. The resulting emission only happens when the current Observable emits (and + not when any of the other sources emit, unlike combineLatest). + If a source doesn't produce any value and just completes, the sequence is completed immediately. + If the upstream completes before all other sources have produced at least one value, the sequence completes + without emission. +

        + +

        +
        Scheduler:
        +
        This operator does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the first other source's value type
        +
        T2 - the second other source's value type
        +
        T3 - the third other source's value type
        +
        T4 - the fourth other source's value type
        +
        R - the result value type
        +
        Parameters:
        +
        source1 - the first other ObservableSource
        +
        source2 - the second other ObservableSource
        +
        source3 - the third other ObservableSource
        +
        source4 - the fourth other ObservableSource
        +
        combiner - the function called with an array of values from each participating ObservableSource
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, + source4 or combiner is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        withLatestFrom

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> withLatestFrom(@NonNull ObservableSource<?>[] others,
+        @NonNull Function<? super Object[],R> combiner)
        +
        Combines the value emission from the current Observable with the latest emissions from the + other ObservableSources via a function to produce the output item. + +

        Note that this operator doesn't emit anything until all other sources have produced at + least one value. The resulting emission only happens when the current Observable emits (and + not when any of the other sources emit, unlike combineLatest). + If a source doesn't produce any value and just completes, the sequence is completed immediately. + If the upstream completes before all other sources have produced at least one value, the sequence completes + without emission. +

        + +

        +
        Scheduler:
        +
        This operator does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        others - the array of other sources
        +
        combiner - the function called with an array of values from each participating ObservableSource
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if others or combiner is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        withLatestFrom

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> withLatestFrom(@NonNull Iterable<? extends ObservableSource<?>> others,
+        @NonNull Function<? super Object[],R> combiner)
        +
        Combines the value emission from the current Observable with the latest emissions from the + other ObservableSources via a function to produce the output item. + +

        Note that this operator doesn't emit anything until all other sources have produced at + least one value. The resulting emission only happens when the current Observable emits (and + not when any of the other sources emit, unlike combineLatest). + If a source doesn't produce any value and just completes, the sequence is completed immediately. + If the upstream completes before all other sources have produced at least one value, the sequence completes + without emission. +

        + +

        +
        Scheduler:
        +
        This operator does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        others - the iterable of other sources
        +
        combiner - the function called with an array of values from each participating ObservableSource
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if others or combiner is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        zipWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Observable<R> zipWith(@NonNull Iterable<U> other,
+        @NonNull BiFunction<? super T,? super U,? extends R> zipper)
        +
        Returns an Observable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Observable and a specified Iterable sequence. +

        + +

        + Note that the other Iterable is evaluated as items are observed from the current Observable; it is + not pre-consumed. This allows you to zip infinite streams on either side. +

        +
        Scheduler:
        +
        zipWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items in the other Iterable
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        other - the Iterable sequence
        +
        zipper - a function that combines the pairs of items from the current Observable and the Iterable to generate + the items to be emitted by the resulting Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if other or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zipWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Observable<R> zipWith(@NonNull ObservableSource<? extends U> other,
+        @NonNull BiFunction<? super T,? super U,? extends R> zipper)
        +
        Returns an Observable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Observable and another specified ObservableSource. +

        + +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        range(1, 5).doOnComplete(action1).zipWith(range(6, 5).doOnComplete(action2), (a, b) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +
        +
        Scheduler:
        +
        zipWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the other ObservableSource
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        other - the other ObservableSource
        +
        zipper - a function that combines the pairs of items from the current Observable and the other ObservableSource to generate the items to + be emitted by the resulting Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if other or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zipWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Observable<R> zipWith(@NonNull ObservableSource<? extends U> other,
+        @NonNull BiFunction<? super T,? super U,? extends R> zipper,
+        boolean delayError)
        +
        Returns an Observable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Observable and another specified ObservableSource. +

        + +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        range(1, 5).doOnComplete(action1).zipWith(range(6, 5).doOnComplete(action2), (a, b) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +
        +
        Scheduler:
        +
        zipWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the other ObservableSource
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        other - the other ObservableSource
        +
        zipper - a function that combines the pairs of items from the current Observable and the other ObservableSource to generate the items to + be emitted by the resulting Observable
        +
        delayError - if true, errors from the current Observable or the other ObservableSource is delayed until both terminate
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if other or zipper is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zipWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Observable<R> zipWith(@NonNull ObservableSource<? extends U> other,
+        @NonNull BiFunction<? super T,? super U,? extends R> zipper,
+        boolean delayError,
+        int bufferSize)
        +
        Returns an Observable that emits items that are the result of applying a specified function to pairs of + values, one each from the current Observable and another specified ObservableSource. +

        + +

        + The operator subscribes to its sources in order they are specified and completes eagerly if + one of the sources is shorter than the rest while disposing the other sources. Therefore, it + is possible those other sources will never be able to run to completion (and thus not calling + doOnComplete()). This can also happen if the sources are exactly the same length; if + source A completes and B has been consumed and is about to complete, the operator detects A won't + be sending further values and it will dispose B immediately. For example: + 

        range(1, 5).doOnComplete(action1).zipWith(range(6, 5).doOnComplete(action2), (a, b) -> a + b)
        + action1 will be called but action2 won't. +
        To work around this termination property, + use doOnDispose(Action) as well or use using() to do cleanup in case of completion + or a dispose() call. +
        +
        Scheduler:
        +
        zipWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the other ObservableSource
        +
        R - the type of items emitted by the resulting Observable
        +
        Parameters:
        +
        other - the other ObservableSource
        +
        zipper - a function that combines the pairs of items from the current Observable and the other ObservableSource to generate the items to + be emitted by the resulting Observable
        +
        bufferSize - the capacity hint for the buffer in the inner windows
        +
        delayError - if true, errors from the current Observable or the other ObservableSource is delayed until both terminate
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if other or zipper is null
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + + + + + +
        +
      • +

        test

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull TestObserver<T> test(boolean dispose)
        +
        Creates a TestObserver, optionally disposes it and then subscribes + it to the current Observable. + +
        +
        Scheduler:
        +
        test does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        dispose - indicates if the TestObserver should be disposed before + it is subscribed to the current Observable
        +
        Returns:
        +
        the new TestObserver instance
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        fromOptional

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> fromOptional(@NonNull Optional<T> optional)
        +
        Converts the existing value of the provided optional into a just(Object) + or an empty optional into an empty() Observable instance. +

        + +

        + Note that the operator takes an already instantiated optional reference and does not + by any means create this original optional. If the optional is to be created per + consumer upon subscription, use defer(Supplier) around fromOptional: + 

        
+ Observable.defer(() -> Observable.fromOptional(createOptional()));
+
        +
        +
        Scheduler:
        +
        fromOptional does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the optional value
        +
        Parameters:
        +
        optional - the optional value to convert into an Observable
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if optional is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        just(Object), +empty()
        +
        +
        • +
      + + + +
        +
      • +

        fromCompletionStage

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> fromCompletionStage(@NonNull CompletionStage<T> stage)
        +
        Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation. +

        + +

        + Note that the operator takes an already instantiated, running or terminated CompletionStage. + If the CompletionStage is to be created per consumer upon subscription, use defer(Supplier) + around fromCompletionStage: + 

        
+ Observable.defer(() -> Observable.fromCompletionStage(createCompletionStage()));
+
        +

        + If the CompletionStage completes with null, a NullPointerException is signaled. +

        + Canceling the flow can't cancel the execution of the CompletionStage because CompletionStage + itself doesn't support cancellation. Instead, the operator detaches from the CompletionStage. +

        +
        Scheduler:
        +
        fromCompletionStage does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the CompletionStage
        +
        Parameters:
        +
        stage - the CompletionStage to convert to Observable and signal its terminal value or error
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if stage is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        fromStream

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Observable<T> fromStream(@NonNull Stream<T> stream)
        +
        Converts a Stream into a finite Observable and emits its items in the sequence. +

        + +

        + The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when + closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). + If a Stream should not be closed, turn it into an Iterable and use fromIterable(Iterable): + 

        
+ Stream<T> stream = ...
+ Observable.fromIterable(stream::iterator);
+
        +

        + Note that Streams can be consumed only once; any subsequent attempt to consume a Stream + will result in an IllegalStateException. +

        + Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): + 

        
+ IntStream intStream = IntStream.rangeClosed(1, 10);
+ Observable.fromStream(intStream.boxed());
+
        +

        + Stream does not support concurrent usage so creating and/or consuming the same instance multiple times + from multiple threads can lead to undefined behavior. +

        +
        Scheduler:
        +
        fromStream does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the source Stream
        +
        Parameters:
        +
        stream - the Stream of values to emit
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if stream is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        fromIterable(Iterable)
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        blockingStream

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Stream<T> blockingStream()
        +
        Creates a sequential Stream to consume or process the current Observable in a blocking manner via + the Java Stream API. +

        + +

        + Cancellation of the upstream is done via BaseStream.close(), therefore, it is strongly recommended the + consumption is performed within a try-with-resources construct: + 

        
+ Observable<Integer> source = Observable.range(1, 10)
+        .subscribeOn(Schedulers.computation());
+
+ try (Stream<Integer> stream = source.blockingStream()) {
+     stream.limit(3).forEach(System.out::println);
+ }
+
        +
        +
        Scheduler:
        +
        blockingStream does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Stream instance
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        blockingStream(int)
        +
        +
        • +
      + + + +
        +
      • +

        blockingStream

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Stream<T> blockingStream(int capacityHint)
        +
        Creates a sequential Stream to consume or process the current Observable in a blocking manner via + the Java Stream API. +

        + +

        + Cancellation of the upstream is done via BaseStream.close(), therefore, it is strongly recommended the + consumption is performed within a try-with-resources construct: + 

        
+ Observable<Integer> source = Observable.range(1, 10)
+        .subscribeOn(Schedulers.computation());
+
+ try (Stream<Integer> stream = source.blockingStream(4)) {
+     stream.limit(3).forEach(System.out::println);
+ }
+
        +
        +
        Scheduler:
        +
        blockingStream does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        capacityHint - the expected number of items to be buffered
        +
        Returns:
        +
        the new Stream instance
        +
        Throws:
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatMapStream

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> concatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper)
        +
        Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion. +

        + +

        + Due to the blocking and sequential nature of Java Streams, the streams are mapped and consumed in a sequential fashion + without interleaving (unlike a more general flatMap(Function)). Therefore, flatMapStream and + concatMapStream are identical operators and are provided as aliases. +

        + The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when + closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). + If a Stream should not be closed, turn it into an Iterable and use concatMapIterable(Function): + 

        
+ source.concatMapIterable(v -> createStream(v)::iterator);
+
        +

        + Note that Streams can be consumed only once; any subsequent attempt to consume a Stream + will result in an IllegalStateException. +

        + Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): + 

        
+ source.concatMapStream(v -> IntStream.rangeClosed(v + 1, v + 10).boxed());
+
        +

        + Stream does not support concurrent usage so creating and/or consuming the same instance multiple times + from multiple threads can lead to undefined behavior. +

        +
        Scheduler:
        +
        concatMapStream does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the Streams and the result
        +
        Parameters:
        +
        mapper - the function that receives an upstream item and should return a Stream whose elements + will be emitted to the downstream
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        concatMap(Function), +concatMapIterable(Function), +flatMapStream(Function)
        +
        +
        • +
      + + + +
        +
      • +

        flatMapStream

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> flatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper)
        +
        Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion. +

        + +

        + Due to the blocking and sequential nature of Java Streams, the streams are mapped and consumed in a sequential fashion + without interleaving (unlike a more general flatMap(Function)). Therefore, flatMapStream and + concatMapStream are identical operators and are provided as aliases. +

        + The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when + closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). + If a Stream should not be closed, turn it into an Iterable and use flatMapIterable(Function): + 

        
+ source.flatMapIterable(v -> createStream(v)::iterator);
+
        +

        + Note that Streams can be consumed only once; any subsequent attempt to consume a Stream + will result in an IllegalStateException. +

        + Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): + 

        
+ source.flatMapStream(v -> IntStream.rangeClosed(v + 1, v + 10).boxed());
+
        +

        + Stream does not support concurrent usage so creating and/or consuming the same instance multiple times + from multiple threads can lead to undefined behavior. +

        +
        Scheduler:
        +
        flatMapStream does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the Streams and the result
        +
        Parameters:
        +
        mapper - the function that receives an upstream item and should return a Stream whose elements + will be emitted to the downstream
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        flatMap(Function), +flatMapIterable(Function)
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableConverter.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableConverter.html new file mode 100644 index 0000000000..c0e3c617ae --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableConverter.html @@ -0,0 +1,245 @@ + + + + + +ObservableConverter (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface ObservableConverter<T,R>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the upstream type
    +
    R - the output type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface ObservableConverter<T,R>
    +
    Convenience interface and callback used by the Observable.to(io.reactivex.rxjava3.core.ObservableConverter<T, ? extends R>) operator to turn an Observable into another + value fluently. +

    History: 2.1.7 - experimental

    +
    +
    Since:
    +
    2.2
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        apply

        +
        R apply(@NonNull
+        @NonNull Observable<T> upstream)
        +
        Applies a function to the upstream Observable and returns a converted value of type R.
        +
        +
        Parameters:
        +
        upstream - the upstream Observable instance
        +
        Returns:
        +
        the converted value
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableEmitter.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableEmitter.html new file mode 100644 index 0000000000..8693f58b35 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableEmitter.html @@ -0,0 +1,375 @@ + + + + + +ObservableEmitter (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface ObservableEmitter<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type to emit
    +
    +
    +
    All Superinterfaces:
    +
    Emitter<T>
    +
    +
    +
    +
    public interface ObservableEmitter<T>
+extends Emitter<T>
    +
    Abstraction over an RxJava Observer that allows associating + a resource with it. +

    + The Emitter.onNext(Object), Emitter.onError(Throwable), tryOnError(Throwable) + and Emitter.onComplete() methods should be called in a sequential manner, just like the + Observer's methods should be. + Use the ObservableEmitter the serialize() method returns instead of the original + ObservableEmitter instance provided by the generator routine if you want to ensure this. + The other methods are thread-safe. +

    + The emitter allows the registration of a single resource, in the form of a Disposable + or Cancellable via setDisposable(Disposable) or setCancellable(Cancellable) + respectively. The emitter implementations will dispose/cancel this instance when the + downstream cancels the flow or after the event generator logic calls Emitter.onError(Throwable), + Emitter.onComplete() or when tryOnError(Throwable) succeeds. +

    + Only one Disposable or Cancellable object can be associated with the emitter at + a time. Calling either set method will dispose/cancel any previous object. If there + is a need for handling multiple resources, one can create a CompositeDisposable + and associate that with the emitter instead. +

    + The Cancellable is logically equivalent to Disposable but allows using cleanup logic that can + throw a checked exception (such as many close() methods on Java IO components). Since + the release of resources happens after the terminal events have been delivered or the sequence gets + cancelled, exceptions throw within Cancellable are routed to the global error handler via + RxJavaPlugins.onError(Throwable).

    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        setDisposable

        +
        void setDisposable(@Nullable
+                   @Nullable Disposable d)
        +
        Sets a Disposable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled. +

        This method is thread-safe.

        +
        +
        Parameters:
        +
        d - the Disposable, null is allowed
        +
        +
        • +
      + + + +
        +
      • +

        setCancellable

        +
        void setCancellable(@Nullable
+                    @Nullable Cancellable c)
        +
        Sets a Cancellable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled. +

        This method is thread-safe.

        +
        +
        Parameters:
        +
        c - the Cancellable resource, null is allowed
        +
        +
        • +
      + + + +
        +
      • +

        isDisposed

        +
        boolean isDisposed()
        +
        Returns true if the downstream disposed the sequence or the + emitter was terminated via Emitter.onError(Throwable), Emitter.onComplete() or a + successful tryOnError(Throwable). +

        This method is thread-safe.

        +
        +
        Returns:
        +
        true if the downstream disposed the sequence or the emitter was terminated
        +
        +
        • +
      + + + + + + + +
        +
      • +

        tryOnError

        +
        boolean tryOnError(@NonNull
+                   @NonNull Throwable t)
        +
        Attempts to emit the specified Throwable error if the downstream + hasn't cancelled the sequence or is otherwise terminated, returning false + if the emission is not allowed to happen due to lifecycle restrictions. +

        + Unlike Emitter.onError(Throwable), the RxjavaPlugins.onError + is not called if the error could not be delivered. +

        History: 2.1.1 - experimental

        +
        +
        Parameters:
        +
        t - the Throwable error to signal if possible
        +
        Returns:
        +
        true if successful, false if the downstream is not able to accept further + events
        +
        Since:
        +
        2.2
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableOnSubscribe.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableOnSubscribe.html new file mode 100644 index 0000000000..b7204b8521 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableOnSubscribe.html @@ -0,0 +1,241 @@ + + + + + +ObservableOnSubscribe (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface ObservableOnSubscribe<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type pushed
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface ObservableOnSubscribe<T>
    +
    A functional interface that has a subscribe() method that receives + an ObservableEmitter instance that allows pushing + events in a cancellation-safe manner.
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableOperator.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableOperator.html new file mode 100644 index 0000000000..e5615b477c --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableOperator.html @@ -0,0 +1,243 @@ + + + + + +ObservableOperator (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface ObservableOperator<Downstream,Upstream>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    Downstream - the value type of the downstream
    +
    Upstream - the value type of the upstream
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface ObservableOperator<Downstream,Upstream>
    +
    Interface to map/wrap a downstream Observer to an upstream Observer.
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableSource.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableSource.html new file mode 100644 index 0000000000..6804bcf1b4 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableSource.html @@ -0,0 +1,247 @@ + + + + + +ObservableSource (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface ObservableSource<T>

+
+
+
+ +
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableTransformer.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableTransformer.html new file mode 100644 index 0000000000..08b95b2cbe --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/ObservableTransformer.html @@ -0,0 +1,242 @@ + + + + + +ObservableTransformer (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface ObservableTransformer<Upstream,Downstream>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    Upstream - the upstream value type
    +
    Downstream - the downstream value type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface ObservableTransformer<Upstream,Downstream>
    +
    Interface to compose Observables.
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Observer.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Observer.html new file mode 100644 index 0000000000..24aa6948cc --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Observer.html @@ -0,0 +1,367 @@ + + + + + +Observer (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface Observer<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the type of item the Observer expects to observe
    +
    +
    +
    All Known Implementing Classes:
    +
    AsyncSubject, BehaviorSubject, DefaultObserver, DisposableObserver, PublishSubject, ReplaySubject, ResourceObserver, SafeObserver, SerializedObserver, Subject, TestObserver, UnicastSubject
    +
    +
    +
    +
    public interface Observer<T>
    +
    Provides a mechanism for receiving push-based notifications. +

    + When an Observer is subscribed to an ObservableSource through the ObservableSource.subscribe(Observer) method, + the ObservableSource calls onSubscribe(Disposable) with a Disposable that allows + disposing the sequence at any time, then the + ObservableSource may call the Observer's onNext(T) method any number of times + to provide notifications. A well-behaved + ObservableSource will call an Observer's onComplete() method exactly once or the Observer's + onError(java.lang.Throwable) method exactly once. +

    + Calling the Observer's method must happen in a serialized fashion, that is, they must not + be invoked concurrently by multiple threads in an overlapping fashion and the invocation pattern must + adhere to the following protocol: + 

        onSubscribe onNext* (onError | onComplete)?
    +

    + Subscribing an Observer to multiple ObservableSources is not recommended. If such reuse + happens, it is the duty of the Observer implementation to be ready to receive multiple calls to + its methods and ensure proper concurrent behavior of its business logic. +

    + Calling onSubscribe(Disposable), onNext(Object) or onError(Throwable) with a + null argument is forbidden. +

    + The implementations of the onXXX methods should avoid throwing runtime exceptions other than the following cases + (see Rule 2.13 of the Reactive Streams specification): +

      +
    • If the argument is null, the methods can throw a NullPointerException. + Note though that RxJava prevents nulls to enter into the flow and thus there is generally no + need to check for nulls in flows assembled from standard sources and intermediate operators. +
      • +
    • If there is a fatal error (such as VirtualMachineError).
      • +
    +

    + Violating Rule 2.13 results in undefined flow behavior. Generally, the following can happen: +

    + From the Observable's perspective, an Observer is the end consumer thus it is the Observer's + responsibility to handle the error case and signal it "further down". This means unreliable code in the onXXX + methods should be wrapped into `try-catch`es, specifically in onError(Throwable) or onComplete(), and handled there + (for example, by logging it or presenting the user with an error dialog). However, if the error would be thrown from + onNext(Object), Rule 2.13 mandates + the implementation calls Disposable.dispose() and signals the exception in a way that is adequate to the target context, + for example, by calling onError(Throwable) on the same Observer instance. +

    + If, for some reason, the Observer won't follow Rule 2.13, the Observable.safeSubscribe(Observer) can wrap it + with the necessary safeguards and route exceptions thrown from onNext into onError and route exceptions thrown + from onError and onComplete into the global error handler via RxJavaPlugins.onError(Throwable).

    +
    +
    See Also:
    +
    ReactiveX documentation: Observable
    +
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Scheduler.Worker.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Scheduler.Worker.html new file mode 100644 index 0000000000..649d2d7b14 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Scheduler.Worker.html @@ -0,0 +1,450 @@ + + + + + +Scheduler.Worker (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Class Scheduler.Worker

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Disposable
    +
    +
    +
    Enclosing class:
    +
    Scheduler
    +
    +
    +
    +
    public abstract static class Scheduler.Worker
+extends Object
+implements Disposable
    +
    Represents an isolated, sequential worker of a parent Scheduler for executing Runnable tasks on + an underlying task-execution scheme (such as custom Threads, event loop, Executor or Actor system). +

    + Disposing the Scheduler.Worker should cancel all outstanding work and allows resource cleanup. +

    + The default implementations of schedule(Runnable) and schedulePeriodically(Runnable, long, long, TimeUnit) + delegate to the abstract schedule(Runnable, long, TimeUnit) method. Its implementation is encouraged to + track the individual Runnable tasks while they are waiting to be executed (with or without delay) so that + Disposable.dispose() can prevent their execution or potentially interrupt them if they are currently running. +

    + The default implementation of the now(TimeUnit) method returns current System.currentTimeMillis() + value in the desired time unit, unless rx3.scheduler.use-nanotime (boolean) is set. When the property is set to + true, the method uses System.nanoTime() as its basis instead. Custom Worker implementations can override this + to provide specialized time accounting (such as virtual time to be advanced programmatically). + Note that operators requiring a scheduler may rely on either of the now() calls provided by + Scheduler or Worker respectively, therefore, it is recommended they represent a logically + consistent source of the current time. +

    + The default implementation of the schedulePeriodically(Runnable, long, long, TimeUnit) method uses + the schedule(Runnable, long, TimeUnit) for scheduling the Runnable task periodically. + The algorithm calculates the next absolute time when the task should run again and schedules this execution + based on the relative time between it and now(TimeUnit). However, drifts or changes in the + system clock would affect this calculation either by scheduling subsequent runs too frequently or too far apart. + Therefore, the default implementation uses the Scheduler.clockDriftTolerance() value (set via + rx3.scheduler.drift-tolerance and rx3.scheduler.drift-tolerance-unit) to detect a drift in now(TimeUnit) and + re-adjust the absolute/relative time calculation accordingly. +

    + If the Worker is disposed, the schedule methods + should return the Disposable.disposed() singleton instance indicating the disposed + state to the caller. Since the Disposable.dispose() call can happen on any thread, the schedule implementations + should make best effort to cancel tasks immediately after those tasks have been submitted to the + underlying task-execution scheme if the dispose was detected after this submission. +

    + All methods on the Worker class should be thread safe.

    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Worker

        +
        public Worker()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        schedule

        +
        @NonNull
+public abstract @NonNull Disposable schedule(@NonNull
+                                                      @NonNull Runnable run,
+                                                      long delay,
+                                                      @NonNull
+                                                      @NonNull TimeUnit unit)
        +
        Schedules an Runnable for execution at some point in the future specified by a time delay + relative to the current time. +

        + Note to implementors: non-positive delayTime should be regarded as non-delayed schedule, i.e., + as if the schedule(Runnable) was called.

        +
        +
        Parameters:
        +
        run - the Runnable to schedule
        +
        delay - time to "wait" before executing the action; non-positive values indicate an non-delayed + schedule
        +
        unit - the time unit of delayTime
        +
        Returns:
        +
        a Disposable to be able to unsubscribe the action (cancel it if not executed)
        +
        Throws:
        +
        NullPointerException - if run or unit is null
        +
        +
        • +
      + + + +
        +
      • +

        schedulePeriodically

        +
        @NonNull
+public @NonNull Disposable schedulePeriodically(@NonNull
+                                                         @NonNull Runnable run,
+                                                         long initialDelay,
+                                                         long period,
+                                                         @NonNull
+                                                         @NonNull TimeUnit unit)
        +
        Schedules a periodic execution of the given task with the given initial time delay and repeat period. +

        + The default implementation schedules and reschedules the Runnable task via the + schedule(Runnable, long, TimeUnit) + method over and over and at a fixed rate, that is, the first execution will be after the + initialDelay, the second after initialDelay + period, the third after + initialDelay + 2 * period, and so on. +

        + Note to implementors: non-positive initialTime and period should be regarded as + non-delayed scheduling of the first and any subsequent executions. + In addition, a more specific Worker implementation should override this method + if it can perform the periodic task execution with less overhead (such as by avoiding the + creation of the wrapper and tracker objects upon each periodic invocation of the + common schedule(Runnable, long, TimeUnit) method).

        +
        +
        Parameters:
        +
        run - the Runnable to execute periodically
        +
        initialDelay - time to wait before executing the action for the first time; non-positive values indicate + an non-delayed schedule
        +
        period - the time interval to wait each time in between executing the action; non-positive values + indicate no delay between repeated schedules
        +
        unit - the time unit of period
        +
        Returns:
        +
        a Disposable to be able to unsubscribe the action (cancel it if not executed)
        +
        Throws:
        +
        NullPointerException - if run or unit is null
        +
        +
        • +
      + + + +
        +
      • +

        now

        +
        public long now(@NonNull
+                @NonNull TimeUnit unit)
        +
        Returns the 'current time' of the Worker in the specified time unit.
        +
        +
        Parameters:
        +
        unit - the time unit
        +
        Returns:
        +
        the 'current time'
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Scheduler.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Scheduler.html new file mode 100644 index 0000000000..70bc2152f3 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Scheduler.html @@ -0,0 +1,696 @@ + + + + + +Scheduler (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Class Scheduler

+
+
+ +
+
    +
  • +
    +
    Direct Known Subclasses:
    +
    TestScheduler
    +
    +
    +
    +
    public abstract class Scheduler
+extends Object
    +
    A Scheduler is an object that specifies an API for scheduling + units of work provided in the form of Runnables to be + executed without delay (effectively as soon as possible), after a specified time delay or periodically + and represents an abstraction over an asynchronous boundary that ensures + these units of work get executed by some underlying task-execution scheme + (such as custom Threads, event loop, Executor or Actor system) + with some uniform properties and guarantees regardless of the particular underlying + scheme. +

    + You can get various standard, RxJava-specific instances of this class via + the static methods of the Schedulers utility class. +

    + The so-called Scheduler.Workers of a Scheduler can be created via the createWorker() method which allow the scheduling + of multiple Runnable tasks in an isolated manner. Runnable tasks scheduled on a Worker are guaranteed to be + executed sequentially and in a non-overlapping fashion. Non-delayed Runnable tasks are guaranteed to execute in a + First-In-First-Out order but their execution may be interleaved with delayed tasks. + In addition, outstanding or running tasks can be cancelled together via + Disposable.dispose() without affecting any other Worker instances of the same Scheduler. +

    + Implementations of the scheduleDirect(java.lang.Runnable) and Scheduler.Worker.schedule(java.lang.Runnable) methods are encouraged to call the RxJavaPlugins.onSchedule(Runnable) + method to allow a scheduler hook to manipulate (wrap or replace) the original Runnable task before it is submitted to the + underlying task-execution scheme. +

    + The default implementations of the scheduleDirect methods provided by this abstract class + delegate to the respective schedule methods in the Scheduler.Worker instance created via createWorker() + for each individual Runnable task submitted. Implementors of this class are encouraged to provide + a more efficient direct scheduling implementation to avoid the time and memory overhead of creating such Workers + for every task. + This delegation is done via special wrapper instances around the original Runnable before calling the respective + Worker.schedule method. Note that this can lead to multiple RxJavaPlugins.onSchedule calls and potentially + multiple hooks applied. Therefore, the default implementations of scheduleDirect (and the Scheduler.Worker.schedulePeriodically(Runnable, long, long, TimeUnit)) + wrap the incoming Runnable into a class that implements the SchedulerRunnableIntrospection + interface which can grant access to the original or hooked Runnable, thus, a repeated RxJavaPlugins.onSchedule + can detect the earlier hook and not apply a new one over again. +

    + The default implementation of now(TimeUnit) and Scheduler.Worker.now(TimeUnit) methods to return current System.currentTimeMillis() + value in the desired time unit, unless rx3.scheduler.use-nanotime (boolean) is set. When the property is set to + true, the method uses System.nanoTime() as its basis instead. Custom Scheduler implementations can override this + to provide specialized time accounting (such as virtual time to be advanced programmatically). + Note that operators requiring a Scheduler may rely on either of the now() calls provided by + Scheduler or Worker respectively, therefore, it is recommended they represent a logically + consistent source of the current time. +

    + The default implementation of the Scheduler.Worker.schedulePeriodically(Runnable, long, long, TimeUnit) method uses + the Scheduler.Worker.schedule(Runnable, long, TimeUnit) for scheduling the Runnable task periodically. + The algorithm calculates the next absolute time when the task should run again and schedules this execution + based on the relative time between it and Scheduler.Worker.now(TimeUnit). However, drifts or changes in the + system clock could affect this calculation either by scheduling subsequent runs too frequently or too far apart. + Therefore, the default implementation uses the clockDriftTolerance() value (set via + rx3.scheduler.drift-tolerance and rx3.scheduler.drift-tolerance-unit) to detect a + drift in Scheduler.Worker.now(TimeUnit) and re-adjust the absolute/relative time calculation accordingly. +

    + The default implementations of start() and shutdown() do nothing and should be overridden if the + underlying task-execution scheme supports stopping and restarting itself. +

    + If the Scheduler is shut down or a Worker is disposed, the schedule methods + should return the Disposable.disposed() singleton instance indicating the shut down/disposed + state to the caller. Since the shutdown or dispose can happen from any thread, the schedule implementations + should make best effort to cancel tasks immediately after those tasks have been submitted to the + underlying task-execution scheme if the shutdown/dispose was detected after this submission. +

    + All methods on the Scheduler and Worker classes should be thread safe.

    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Scheduler

        +
        public Scheduler()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        clockDriftTolerance

        +
        public static long clockDriftTolerance()
        +
        Returns the clock drift tolerance in nanoseconds. +

        Related system properties: +

          +
        • rx3.scheduler.drift-tolerance, long, default 15
          • +
        • rx3.scheduler.drift-tolerance-unit, string, default minutes, + supports seconds and milliseconds. +
        +
        +
        Returns:
        +
        the tolerance in nanoseconds
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        createWorker

        +
        @NonNull
+public abstract @NonNull Scheduler.Worker createWorker()
        +
        Retrieves or creates a new Scheduler.Worker that represents sequential execution of actions. +

        + When work is completed, the Worker instance should be released + by calling Disposable.dispose() to avoid potential resource leaks in the + underlying task-execution scheme. +

        + Work on a Scheduler.Worker is guaranteed to be sequential and non-overlapping.

        +
        +
        Returns:
        +
        a Worker representing a serial queue of actions to be executed
        +
        +
        • +
      + + + +
        +
      • +

        now

        +
        public long now(@NonNull
+                @NonNull TimeUnit unit)
        +
        Returns the 'current time' of the Scheduler in the specified time unit.
        +
        +
        Parameters:
        +
        unit - the time unit
        +
        Returns:
        +
        the 'current time'
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        start

        +
        public void start()
        +
        Allows the Scheduler instance to start threads + and accept tasks on them. +

        + Implementations should make sure the call is idempotent, thread-safe and + should not throw any RuntimeException if it doesn't support this + functionality.

        +
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        shutdown

        +
        public void shutdown()
        +
        Instructs the Scheduler instance to stop threads, + stop accepting tasks on any outstanding Scheduler.Worker instances + and clean up any associated resources with this Scheduler. +

        + Implementations should make sure the call is idempotent, thread-safe and + should not throw any RuntimeException if it doesn't support this + functionality.

        +
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        scheduleDirect

        +
        @NonNull
+public @NonNull Disposable scheduleDirect(@NonNull
+                                                   @NonNull Runnable run)
        +
        Schedules the given task on this Scheduler without any time delay. + +

        + This method is safe to be called from multiple threads but there are no + ordering or non-overlapping guarantees between tasks.

        +
        +
        Parameters:
        +
        run - the task to execute
        +
        Returns:
        +
        the Disposable instance that let's one cancel this particular task.
        +
        Throws:
        +
        NullPointerException - if run is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        scheduleDirect

        +
        @NonNull
+public @NonNull Disposable scheduleDirect(@NonNull
+                                                   @NonNull Runnable run,
+                                                   long delay,
+                                                   @NonNull
+                                                   @NonNull TimeUnit unit)
        +
        Schedules the execution of the given task with the given time delay. + +

        + This method is safe to be called from multiple threads but there are no + ordering guarantees between tasks.

        +
        +
        Parameters:
        +
        run - the task to schedule
        +
        delay - the delay amount, non-positive values indicate non-delayed scheduling
        +
        unit - the unit of measure of the delay amount
        +
        Returns:
        +
        the Disposable that let's one cancel this particular delayed task.
        +
        Throws:
        +
        NullPointerException - if run or unit is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        schedulePeriodicallyDirect

        +
        @NonNull
+public @NonNull Disposable schedulePeriodicallyDirect(@NonNull
+                                                               @NonNull Runnable run,
+                                                               long initialDelay,
+                                                               long period,
+                                                               @NonNull
+                                                               @NonNull TimeUnit unit)
        +
        Schedules a periodic execution of the given task with the given initial time delay and repeat period. + +

        + This method is safe to be called from multiple threads but there are no + ordering guarantees between tasks. + +

        + The periodic execution is at a fixed rate, that is, the first execution will be after the + initialDelay, the second after initialDelay + period, the third after + initialDelay + 2 * period, and so on.

        +
        +
        Parameters:
        +
        run - the task to schedule
        +
        initialDelay - the initial delay amount, non-positive values indicate non-delayed scheduling
        +
        period - the period at which the task should be re-executed
        +
        unit - the unit of measure of the delay amount
        +
        Returns:
        +
        the Disposable that let's one cancel this particular delayed task.
        +
        Throws:
        +
        NullPointerException - if run or unit is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        when

        +
        @NonNull
+public <S extends Scheduler & Disposable> S when(@NonNull
+                                                          @NonNull Function<Flowable<Flowable<Completable>>,Completable> combine)
        +
        Allows the use of operators for controlling the timing around when + actions scheduled on workers are actually done. This makes it possible to + layer additional behavior on this Scheduler. The only parameter + is a function that flattens an Flowable of Flowable + of Completables into just one Completable. There must be + a chain of operators connecting the returned value to the source + Flowable otherwise any work scheduled on the returned + Scheduler will not be executed. +

        + When createWorker() is invoked a Flowable of + Completables is onNext'd to the combinator to be flattened. If + the inner Flowable is not immediately subscribed to an calls to + Scheduler.Worker.schedule(java.lang.Runnable) are buffered. Once the Flowable is + subscribed to actions are then onNext'd as Completables. +

        + Finally the actions scheduled on the parent Scheduler when the + inner most Completables are subscribed to. +

        + When the Scheduler.Worker is unsubscribed the Completable emits an + onComplete and triggers any behavior in the flattening operator. The + Flowable and all Completables give to the flattening + function never onError. +

        + Limit the amount concurrency two at a time without creating a new fix + size thread pool: + + 

        + Scheduler limitScheduler = Schedulers.computation().when(workers -> {
+  // use merge max concurrent to limit the number of concurrent
+  // callbacks two at a time
+  return Completable.merge(Flowable.merge(workers), 2);
+ });
+
        +

        + This is a slightly different way to limit the concurrency but it has some + interesting benefits and drawbacks to the method above. It works by + limited the number of concurrent Scheduler.Workers rather than individual + actions. Generally each Flowable uses its own Scheduler.Worker. + This means that this will essentially limit the number of concurrent + subscribes. The danger comes from using operators like + Flowable.zip(org.reactivestreams.Publisher, org.reactivestreams.Publisher, io.reactivex.rxjava3.functions.BiFunction) where + subscribing to the first Flowable could deadlock the + subscription to the second. + + 

        + Scheduler limitScheduler = Schedulers.computation().when(workers -> {
+  // use merge max concurrent to limit the number of concurrent
+  // Flowables two at a time
+  return Completable.merge(Flowable.merge(workers, 2));
+ });
+
        + + Slowing down the rate to no more than than 1 a second. This suffers from + the same problem as the one above I could find an Flowable + operator that limits the rate without dropping the values (aka leaky + bucket algorithm). + + 
        + Scheduler slowScheduler = Schedulers.computation().when(workers -> {
+  // use concatenate to make each worker happen one at a time.
+  return Completable.concat(workers.map(actions -> {
+      // delay the starting of the next worker by 1 second.
+      return Completable.merge(actions.delaySubscription(1, TimeUnit.SECONDS));
+  }));
+ });
+
        + +

        History: 2.0.1 - experimental

        +
        +
        Type Parameters:
        +
        S - a Scheduler and a Subscription
        +
        Parameters:
        +
        combine - the function that takes a two-level nested Flowable sequence of a Completable and returns + the Completable that will be subscribed to and should trigger the execution of the scheduled Actions.
        +
        Returns:
        +
        the Scheduler with the customized execution behavior
        +
        Throws:
        +
        NullPointerException - if combine is null
        +
        Since:
        +
        2.1
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Single.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Single.html new file mode 100644 index 0000000000..255c5fbd51 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/Single.html @@ -0,0 +1,8670 @@ + + + + + +Single (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Class Single<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the type of the item emitted by the Single
    +
    +
    +
    All Implemented Interfaces:
    +
    SingleSource<T>
    +
    +
    +
    Direct Known Subclasses:
    +
    SingleSubject
    +
    +
    +
    +
    public abstract class Single<T>
+extends Object
+implements SingleSource<T>
    +
    The Single class implements the Reactive Pattern for a single value response. +

    + Single behaves similarly to Observable except that it can only emit either a single successful + value or an error (there is no onComplete notification as there is for an Observable). +

    + The Single class implements the SingleSource base interface and the default consumer + type it interacts with is the SingleObserver via the subscribe(SingleObserver) method. +

    + The Single operates with the following sequential protocol: + 

    +     onSubscribe (onSuccess | onError)?
+
    +

    + Note that onSuccess and onError are mutually exclusive events; unlike Observable, + onSuccess is never followed by onError. +

    + Like Observable, a running Single can be stopped through the Disposable instance + provided to consumers through SingleObserver.onSubscribe(io.reactivex.rxjava3.disposables.Disposable). +

    + Like an Observable, a Single is lazy, can be either "hot" or "cold", synchronous or + asynchronous. Single instances returned by the methods of this class are cold + and there is a standard hot implementation in the form of a subject: + SingleSubject. +

    + The documentation for this class makes use of marble diagrams. The following legend explains these diagrams: +

    + +

    + See Flowable or Observable for the + implementation of the Reactive Pattern for a stream or vector of values. +

    + For more information see the ReactiveX + documentation. +

    + Example: + 

    
+ Disposable d = Single.just("Hello World")
+    .delay(10, TimeUnit.SECONDS, Schedulers.io())
+    .subscribeWith(new DisposableSingleObserver<String>() {
+        @Override
+        public void onStart() {
+            System.out.println("Started");
+        }
+
+        @Override
+        public void onSuccess(String value) {
+            System.out.println("Success: " + value);
+        }
+
+        @Override
+        public void onError(Throwable error) {
+            error.printStackTrace();
+        }
+    });
+ 
+ Thread.sleep(5000);
+ 
+ d.dispose();
+
    +

    + Note that by design, subscriptions via subscribe(SingleObserver) can't be disposed + from the outside (hence the + void return of the subscribe(SingleObserver) method) and it is the + responsibility of the implementor of the SingleObserver to allow this to happen. + RxJava supports such usage with the standard + DisposableSingleObserver instance. + For convenience, the subscribeWith(SingleObserver) method is provided as well to + allow working with a SingleObserver (or subclass) instance to be applied with in + a fluent manner (such as in the example above).

    +
    +
    Since:
    +
    2.0
    +
    See Also:
    +
    DisposableSingleObserver
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Single

        +
        public Single()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        concatArrayEager

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+public static <T> @NonNull Flowable<T> concatArrayEager(@NonNull SingleSource<? extends T>... sources)
        +
        Concatenates a sequence of SingleSource eagerly into a single stream of values. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + source SingleSources. The operator buffers the value emitted by these SingleSources and then drains them + in order, each one after the previous one succeeds. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of SingleSources that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        +
        • +
      + + + +
        +
      • +

        concatArrayEagerDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+public static <T> @NonNull Flowable<T> concatArrayEagerDelayError(@NonNull SingleSource<? extends T>... sources)
        +
        Concatenates a sequence of SingleSource eagerly into a single stream of values. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + source SingleSources. The operator buffers the value emitted by these SingleSources and then drains them + in order, each one after the previous one succeeds. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of SingleSources that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> concatDelayError(@NonNull Iterable<? extends SingleSource<? extends T>> sources)
        +
        Concatenates the Iterable sequence of SingleSources into a single sequence by subscribing to each SingleSource, + one after the other, one at a time and delays any errors till the all inner SingleSources terminate + as a Flowable sequence. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        concatDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Iterable sequence of SingleSources
        +
        Returns:
        +
        the new Flowable with the concatenating behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatDelayError(@NonNull Publisher<? extends SingleSource<? extends T>> sources)
        +
        Concatenates the Publisher sequence of SingleSources into a single sequence by subscribing to each inner SingleSource, + one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate + as a Flowable sequence. +

        + +

        +
        Backpressure:
        +
        concatDelayError fully supports backpressure.
        +
        Scheduler:
        +
        concatDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Publisher sequence of SingleSources
        +
        Returns:
        +
        the new Flowable with the concatenating behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Flowable<T> concatDelayError(@NonNull Publisher<? extends SingleSource<? extends T>> sources,
+        int prefetch)
        +
        Concatenates the Publisher sequence of SingleSources into a single sequence by subscribing to each inner SingleSource, + one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate + as a Flowable sequence. +

        + +

        +
        Backpressure:
        +
        concatDelayError fully supports backpressure.
        +
        Scheduler:
        +
        concatDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the Publisher sequence of SingleSources
        +
        prefetch - The number of upstream items to prefetch so that fresh items are + ready to be mapped when a previous SingleSource terminates. + The operator replenishes after half of the prefetch amount has been consumed + and turned into SingleSources.
        +
        Returns:
        +
        the new Flowable with the concatenating behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> concatEager(@NonNull Iterable<? extends SingleSource<? extends T>> sources)
        +
        Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + source SingleSources. The operator buffers the values emitted by these SingleSources and then drains them + in order, each one after the previous one succeeds. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - an Iterable sequence of SingleSource that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> concatEager(@NonNull Iterable<? extends SingleSource<? extends T>> sources,
+        int maxConcurrency)
        +
        Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values and + runs a limited number of the inner sources at once. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + source SingleSources. The operator buffers the values emitted by these SingleSources and then drains them + in order, each one after the previous one succeeds. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - an Iterable sequence of SingleSource that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrently running inner SingleSources; Integer.MAX_VALUE + is interpreted as all inner SingleSources can be active at the same time
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> concatEager(@NonNull Publisher<? extends SingleSource<? extends T>> sources)
        +
        Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source SingleSources as they are observed. The operator buffers the values emitted by these + SingleSources and then drains them in order, each one after the previous one succeeds. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and the outer Publisher is + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of SingleSources that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        +
        • +
      + + + +
        +
      • +

        concatEager

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> concatEager(@NonNull Publisher<? extends SingleSource<? extends T>> sources,
+        int maxConcurrency)
        +
        Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values and + runs a limited number of those inner SingleSources at once. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source SingleSources as they are observed. The operator buffers the values emitted by these + SingleSources and then drains them in order, each one after the previous one succeeds. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and the outer Publisher is + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of SingleSources that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrently running inner SingleSources; Integer.MAX_VALUE + is interpreted as all inner SingleSources can be active at the same time
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Iterable<? extends SingleSource<? extends T>> sources)
        +
        Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values, + delaying errors until all the inner sources terminate. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + source SingleSources. The operator buffers the values emitted by these SingleSources and then drains them + in order, each one after the previous one succeeds. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - an Iterable sequence of SingleSource that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Iterable<? extends SingleSource<? extends T>> sources,
+        int maxConcurrency)
        +
        Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values, + delaying errors until all the inner sources terminate. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + source SingleSources. The operator buffers the values emitted by these SingleSources and then drains them + in order, each one after the previous one succeeds. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - an Iterable sequence of SingleSource that need to be eagerly concatenated
        +
        maxConcurrency - the maximum number of concurrently running inner SingleSources; Integer.MAX_VALUE + is interpreted as all inner SingleSources can be active at the same time
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Publisher<? extends SingleSource<? extends T>> sources)
        +
        Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values, + delaying errors until all the inner and the outer sequence terminate. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source SingleSources as they are observed. The operator buffers the values emitted by these + SingleSources and then drains them in order, each one after the previous one succeeds. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and the outer Publisher is + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of SingleSources that need to be eagerly concatenated
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        concatEagerDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Publisher<? extends SingleSource<? extends T>> sources,
+        int maxConcurrency)
        +
        Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values, + running at most the specified number of those inner SingleSources at once and + delaying errors until all the inner and the outer sequence terminate. +

        + +

        + Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the + emitted source SingleSources as they are observed. The operator buffers the values emitted by these + SingleSources and then drains them in order, each one after the previous one succeeds. +

        +
        Backpressure:
        +
        Backpressure is honored towards the downstream and the outer Publisher is + expected to support backpressure. Violating this assumption, the operator will + signal MissingBackpressureException.
        +
        Scheduler:
        +
        This method does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        sources - a sequence of SingleSources that need to be eagerly concatenated
        +
        maxConcurrency - the number of inner SingleSources to run at once
        +
        Returns:
        +
        the new Flowable instance with the specified concatenation behavior
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Single<T> create(@NonNull SingleOnSubscribe<T> source)
        +
        Provides an API (via a cold Single) that bridges the reactive world with the callback-style world. +

        + +

        + Example: + 

        
+ Single.<Event>create(emitter -> {
+     Callback listener = new Callback() {
+         @Override
+         public void onEvent(Event e) {
+             emitter.onSuccess(e);
+         }
+
+         @Override
+         public void onFailure(Exception e) {
+             emitter.onError(e);
+         }
+     };
+
+     AutoCloseable c = api.someMethod(listener);
+
+     emitter.setCancellable(c::close);
+
+ });
+
        +

        + Whenever a SingleObserver subscribes to the returned Single, the provided + SingleOnSubscribe callback is invoked with a fresh instance of a SingleEmitter + that will interact only with that specific SingleObserver. If this SingleObserver + disposes the flow (making SingleEmitter.isDisposed() return true), + other observers subscribed to the same returned Single are not affected. +

        +
        Scheduler:
        +
        create does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        source - the emitter that is called when a SingleObserver subscribes to the returned Single
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if source is null
        +
        See Also:
        +
        SingleOnSubscribe, +Cancellable
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        fromCallable

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Single<T> fromCallable(@NonNull Callable<? extends T> callable)
        +
        Returns a Single that invokes the given Callable for each incoming SingleObserver + and emits its value or exception to them. +

        + Allows you to defer execution of passed function until SingleObserver subscribes to the Single. + It makes passed function "lazy". + Result of the function invocation will be emitted by the Single. +

        + +

        +
        Scheduler:
        +
        fromCallable does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the Callable throws an exception, the respective Throwable is + delivered to the downstream via SingleObserver.onError(Throwable), + except when the downstream has disposed this Single source. + In this latter case, the Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) as an UndeliverableException. +
        +
        +
        +
        Type Parameters:
        +
        T - the type of the item emitted by the Single.
        +
        Parameters:
        +
        callable - function which execution should be deferred, it will be invoked when SingleObserver will subscribe to the Single.
        +
        Returns:
        +
        the new Single whose SingleObservers' subscriptions trigger an invocation of the given function.
        +
        Throws:
        +
        NullPointerException - if callable is null
        +
        See Also:
        +
        defer(Supplier), +fromSupplier(Supplier)
        +
        +
        • +
      + + + + + + + +
        +
      • +

        fromFuture

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Single<T> fromFuture(@NonNull Future<? extends T> future,
+        long timeout,
+        @NonNull TimeUnit unit)
        +
        Converts a Future into a Single and awaits its outcome, or timeout, in a blocking fashion. +

        + +

        + The operator calls Future.get(long, TimeUnit), which is a blocking method, on the subscription thread. + It is recommended applying subscribeOn(Scheduler) to move this blocking wait to a + background thread, and if the Scheduler supports it, interrupt the wait when the flow + is disposed. +

        + A non-null value is then emitted via onSuccess or any exception is emitted via + onError. If the Future completes with null, a NullPointerException + is signaled. +

        +
        Scheduler:
        +
        fromFuture does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the type of object that the Future returns, and also the type of item to be emitted by + the resulting Single
        +
        Parameters:
        +
        future - the source Future
        +
        timeout - the maximum time to wait before calling get
        +
        unit - the TimeUnit of the timeout argument
        +
        Returns:
        +
        the new Single that emits the item from the source Future
        +
        Throws:
        +
        NullPointerException - if future or unit is null
        +
        See Also:
        +
        ReactiveX operators documentation: From
        +
        +
        • +
      + + + +
        +
      • +

        fromMaybe

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Single<T> fromMaybe(@NonNull MaybeSource<T> maybe)
        +
        Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and + emits onSuccess as a single item, turns an onComplete into NoSuchElementException error signal or + forwards the onError signal. +

        + +

        +
        Scheduler:
        +
        fromMaybe does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type of the MaybeSource element
        +
        Parameters:
        +
        maybe - the MaybeSource instance to subscribe to, not null
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if maybe is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + + + +
        +
      • +

        fromMaybe

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Single<T> fromMaybe(@NonNull MaybeSource<T> maybe,
+        @NonNull T defaultItem)
        +
        Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and + emits onSuccess as a single item, emits the defaultItem for an onComplete signal or + forwards the onError signal. +

        + +

        +
        Scheduler:
        +
        fromMaybe does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type of the MaybeSource element
        +
        Parameters:
        +
        maybe - the MaybeSource instance to subscribe to, not null
        +
        defaultItem - the item to signal if the current MaybeSource is empty
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if maybe or defaultItem is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        fromSupplier

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Single<T> fromSupplier(@NonNull Supplier<? extends T> supplier)
        +
        Returns a Single that invokes passed supplier and emits its result + for each individual SingleObserver that subscribes. +

        + Allows you to defer execution of passed function until a SingleObserver subscribes to the Single. + It makes passed function "lazy". + Result of the function invocation will be emitted by the Single. +

        + +

        +
        Scheduler:
        +
        fromSupplier does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the Supplier throws an exception, the respective Throwable is + delivered to the downstream via SingleObserver.onError(Throwable), + except when the downstream has disposed this Single source. + In this latter case, the Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) as an UndeliverableException. +
        +
        +
        +
        Type Parameters:
        +
        T - the type of the item emitted by the Single.
        +
        Parameters:
        +
        supplier - function which execution should be deferred, it will be invoked when SingleObserver subscribes to the Single.
        +
        Returns:
        +
        the new Single whose SingleObservers' subscriptions trigger an invocation of the given function.
        +
        Throws:
        +
        NullPointerException - if supplier is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        defer(Supplier), +fromCallable(Callable)
        +
        +
        • +
      + + + + + + + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> merge(@NonNull Iterable<? extends SingleSource<? extends T>> sources)
        +
        Merges an Iterable sequence of SingleSource instances into a single Flowable sequence, + running all SingleSources at once. +

        + +

        +
        Backpressure:
        +
        The returned Flowable honors the backpressure of the downstream consumer.
        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source SingleSources signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source SingleSources are disposed. + If more than one SingleSource signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been cancelled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(Iterable) to merge sources and terminate only when all source SingleSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common and resulting value type
        +
        Parameters:
        +
        sources - the Iterable sequence of SingleSource sources
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        mergeDelayError(Iterable)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> merge(@NonNull Publisher<? extends SingleSource<? extends T>> sources)
        +
        Merges a sequence of SingleSource instances emitted by a Publisher into a single Flowable sequence, + running all SingleSources at once. +

        + +

        +
        Backpressure:
        +
        The returned Flowable honors the backpressure of the downstream consumer.
        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source SingleSources signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source SingleSources are disposed. + If more than one SingleSource signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been cancelled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(Publisher) to merge sources and terminate only when all source SingleSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common and resulting value type
        +
        Parameters:
        +
        sources - the Publisher emitting a sequence of SingleSources
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        2.0
        +
        See Also:
        +
        mergeDelayError(Publisher)
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Single<T> merge(@NonNull SingleSource<? extends SingleSource<? extends T>> source)
        +
        Flattens a SingleSource that emits a SingleSingle into a single Single that emits the item + emitted by the nested SingleSource, without any transformation. +

        + +

        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        The resulting Single emits the outer source's or the inner SingleSource's Throwable as is. + Unlike the other merge() operators, this operator won't and can't produce a CompositeException because there is + only one possibility for the outer or the inner SingleSource to emit an onError signal. + Therefore, there is no need for a mergeDelayError(SingleSource<SingleSource<T>>) operator. +
        +
        +
        +
        Type Parameters:
        +
        T - the value type of the sources and the output
        +
        Parameters:
        +
        source - a Single that emits a Single
        +
        Returns:
        +
        the new Single that emits the item that is the result of flattening the Single emitted + by source
        +
        Throws:
        +
        NullPointerException - if source is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + +
        +
      • +

        merge

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> merge(@NonNull SingleSource<? extends T> source1,
+        @NonNull SingleSource<? extends T> source2)
        +
        Flattens two SingleSources into one Flowable sequence, without any transformation. +

        + +

        + You can combine items emitted by multiple SingleSources so that they appear as a single Flowable, by + using the merge method. +

        +
        Backpressure:
        +
        The returned Flowable honors the backpressure of the downstream consumer.
        +
        Scheduler:
        +
        merge does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source SingleSources signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source SingleSources are disposed. + If more than one SingleSource signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been cancelled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeDelayError(SingleSource, SingleSource) to merge sources and terminate only when all source SingleSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common value type
        +
        Parameters:
        +
        source1 - a SingleSource to be merged
        +
        source2 - a SingleSource to be merged
        +
        Returns:
        +
        the new Flowable that emits all of the items emitted by the source SingleSources
        +
        Throws:
        +
        NullPointerException - if source1 or source2 is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge, +mergeDelayError(SingleSource, SingleSource)
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        mergeArray

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+public static <T> @NonNull Flowable<T> mergeArray(SingleSource<? extends T>... sources)
        +
        Merges an array of SingleSource instances into a single Flowable sequence, + running all SingleSources at once. +

        + +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        mergeArray does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If any of the source SingleSources signal a Throwable via onError, the resulting + Flowable terminates with that Throwable and all other source SingleSources are disposed. + If more than one SingleSource signals an error, the resulting Flowable may terminate with the + first one's error or, depending on the concurrency of the sources, may terminate with a + CompositeException containing two or more of the various error signals. + Throwables that didn't make into the composite will be sent (individually) to the global error handler via + RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables + signaled by source(s) after the returned Flowable has been cancelled or terminated with a + (composite) error will be sent to the same global error handler. + Use mergeArrayDelayError(SingleSource...) to merge sources and terminate only when all source SingleSources + have completed or failed with an error. +
        +
        +
        +
        Type Parameters:
        +
        T - the common and resulting value type
        +
        Parameters:
        +
        sources - the array sequence of SingleSource sources
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        mergeArrayDelayError(SingleSource...)
        +
        +
        • +
      + + + +
        +
      • +

        mergeArrayDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+ @NonNull
+public static <T> @NonNull Flowable<T> mergeArrayDelayError(@NonNull SingleSource<? extends T>... sources)
        +
        Flattens an array of SingleSources into one Flowable, in a way that allows a subscriber to receive all + successfully emitted items from each of the source SingleSources without being interrupted by an error + notification from one of them. +

        + +

        + This behaves like merge(Publisher) except that if any of the merged SingleSources notify of an + error via onError, mergeArrayDelayError will refrain from propagating that + error notification until all of the merged SingleSources have finished emitting items. +

        + Even if multiple merged SingleSources send onError notifications, mergeArrayDelayError will only + invoke the onError method of its subscribers once. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream.
        +
        Scheduler:
        +
        mergeArrayDelayError does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common element base type
        +
        Parameters:
        +
        sources - the array of SingleSources
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        See Also:
        +
        ReactiveX operators documentation: Merge
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        never

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Single<T> never()
        +
        Returns a singleton instance of a never-signaling Single (only calls onSubscribe). +

        + +

        +
        Scheduler:
        +
        never does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the target value type
        +
        Returns:
        +
        the singleton never instance
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        switchOnNextDelayError

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Flowable<T> switchOnNextDelayError(@NonNull Publisher<? extends SingleSource<? extends T>> sources)
        +
        Switches between SingleSources emitted by the source Publisher whenever + a new SingleSource is emitted, disposing the previously running SingleSource, + exposing the success items as a Flowable sequence and delaying all errors from + all of them until all terminate. +

        + +

        +
        Backpressure:
        +
        The sources Publisher is consumed in an unbounded manner (requesting Long.MAX_VALUE). + The returned Flowable respects the backpressure from the downstream.
        +
        Scheduler:
        +
        switchOnNextDelayError does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        The returned Flowable collects all errors emitted by either the sources + Publisher or any inner SingleSource and emits them as a CompositeException + when all sources terminate. If only one source ever failed, its error is emitted as-is at the end.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the SingleSources
        +
        Parameters:
        +
        sources - the Publisher sequence of inner SingleSources to switch between
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if sources is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        switchOnNext(Publisher), +ReactiveX operators documentation: Switch
        +
        +
        • +
      + + + +
        +
      • +

        unsafeCreate

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T> @NonNull Single<T> unsafeCreate(@NonNull SingleSource<T> onSubscribe)
        +
        Advanced use only: creates a Single instance without + any safeguards by using a callback that is called with a SingleObserver. +

        + +

        +
        Scheduler:
        +
        unsafeCreate does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        onSubscribe - the function that is called with the subscribing SingleObserver
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if onSubscribe is null
        +
        IllegalArgumentException - if source is a subclass of Single; such + instances don't need conversion and is possibly a port remnant from 1.x or one should use hide() + instead.
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        using

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T,U> @NonNull Single<T> using(@NonNull Supplier<U> resourceSupplier,
+        @NonNull Function<? super U,? extends SingleSource<? extends T>> sourceSupplier,
+        @NonNull Consumer<? super U> resourceCleanup)
        +
        Allows using and disposing a resource while running a SingleSource instance generated from + that resource (similar to a try-with-resources). +

        + +

        +
        Scheduler:
        +
        using does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type of the SingleSource generated
        +
        U - the resource type
        +
        Parameters:
        +
        resourceSupplier - the Supplier called for each SingleObserver to generate a resource object
        +
        sourceSupplier - the function called with the returned resource + object from resourceSupplier and should return a SingleSource instance + to be run by the operator
        +
        resourceCleanup - the consumer of the generated resource that is called exactly once for + that particular resource when the generated SingleSource terminates + (successfully or with an error) or gets disposed.
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if resourceSupplier, sourceSupplier and resourceCleanup is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        using

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T,U> @NonNull Single<T> using(@NonNull Supplier<U> resourceSupplier,
+        @NonNull Function<? super U,? extends SingleSource<? extends T>> sourceSupplier,
+        @NonNull Consumer<? super U> resourceCleanup,
+        boolean eager)
        +
        Allows using and disposing a resource while running a SingleSource instance generated from + that resource (similar to a try-with-resources). +

        + +

        +
        Scheduler:
        +
        using does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type of the SingleSource generated
        +
        U - the resource type
        +
        Parameters:
        +
        resourceSupplier - the Supplier called for each SingleObserver to generate a resource object
        +
        sourceSupplier - the function called with the returned resource + object from resourceSupplier and should return a SingleSource instance + to be run by the operator
        +
        resourceCleanup - the consumer of the generated resource that is called exactly once for + that particular resource when the generated SingleSource terminates + (successfully or with an error) or gets disposed.
        +
        eager - If true then resource disposal will happen either on a dispose() call before the upstream is disposed + or just before the emission of a terminal event (onSuccess or onError). + If false the resource disposal will happen either on a dispose() call after the upstream is disposed + or just after the emission of a terminal event (onSuccess or onError).
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if resourceSupplier, sourceSupplier or resourceCleanup is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T,R> @NonNull Single<R> zip(@NonNull Iterable<? extends SingleSource<? extends T>> sources,
+        @NonNull Function<? super Object[],? extends R> zipper)
        +
        Waits until all SingleSource sources provided by the Iterable sequence signal a success + value and calls a zipper function with an array of these values to return a result + to be emitted to the downstream. +

        + If the Iterable of SingleSources is empty a NoSuchElementException error is signaled after subscription. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. + +

        + +

        + If any of the SingleSources signal an error, all other SingleSources get disposed and the + error emitted to downstream immediately. +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common value type
        +
        R - the result value type
        +
        Parameters:
        +
        sources - the Iterable sequence of SingleSource instances. An empty sequence will result in an + onError signal of NoSuchElementException.
        +
        zipper - the function that receives an array with values from each SingleSource + and should return a value to be emitted to downstream
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if zipper or sources is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
+        @NonNull SingleSource<? extends T2> source2,
+        @NonNull BiFunction<? super T1,? super T2,? extends R> zipper)
        +
        Returns a Single that emits the results of a specified combiner function applied to two items emitted by + two other SingleSources. +

        + +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the first source SingleSource's value type
        +
        T2 - the second source SingleSource's value type
        +
        R - the result value type
        +
        Parameters:
        +
        source1 - the first source SingleSource
        +
        source2 - a second source SingleSource
        +
        zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an + item that will be emitted by the resulting Single
        +
        Returns:
        +
        the new Single that emits the zipped results
        +
        Throws:
        +
        NullPointerException - if source1, source2 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
+        @NonNull SingleSource<? extends T2> source2,
+        @NonNull SingleSource<? extends T3> source3,
+        @NonNull Function3<? super T1,? super T2,? super T3,? extends R> zipper)
        +
        Returns a Single that emits the results of a specified combiner function applied to three items emitted + by three other SingleSources. +

        + +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the first source SingleSource's value type
        +
        T2 - the second source SingleSource's value type
        +
        T3 - the third source SingleSource's value type
        +
        R - the result value type
        +
        Parameters:
        +
        source1 - the first source SingleSource
        +
        source2 - a second source SingleSource
        +
        source3 - a third source SingleSource
        +
        zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an + item that will be emitted by the resulting Single
        +
        Returns:
        +
        the new Single that emits the zipped results
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
+        @NonNull SingleSource<? extends T2> source2,
+        @NonNull SingleSource<? extends T3> source3,
+        @NonNull SingleSource<? extends T4> source4,
+        @NonNull Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)
        +
        Returns a Single that emits the results of a specified combiner function applied to four items + emitted by four other SingleSources. +

        + +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the first source SingleSource's value type
        +
        T2 - the second source SingleSource's value type
        +
        T3 - the third source SingleSource's value type
        +
        T4 - the fourth source SingleSource's value type
        +
        R - the result value type
        +
        Parameters:
        +
        source1 - the first source SingleSource
        +
        source2 - a second source SingleSource
        +
        source3 - a third source SingleSource
        +
        source4 - a fourth source SingleSource
        +
        zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an + item that will be emitted by the resulting Single
        +
        Returns:
        +
        the new Single that emits the zipped results
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, source4 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
+        @NonNull SingleSource<? extends T2> source2,
+        @NonNull SingleSource<? extends T3> source3,
+        @NonNull SingleSource<? extends T4> source4,
+        @NonNull SingleSource<? extends T5> source5,
+        @NonNull Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)
        +
        Returns a Single that emits the results of a specified combiner function applied to five items + emitted by five other SingleSources. +

        + +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the first source SingleSource's value type
        +
        T2 - the second source SingleSource's value type
        +
        T3 - the third source SingleSource's value type
        +
        T4 - the fourth source SingleSource's value type
        +
        T5 - the fifth source SingleSource's value type
        +
        R - the result value type
        +
        Parameters:
        +
        source1 - the first source SingleSource
        +
        source2 - a second source SingleSource
        +
        source3 - a third source SingleSource
        +
        source4 - a fourth source SingleSource
        +
        source5 - a fifth source SingleSource
        +
        zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an + item that will be emitted by the resulting Single
        +
        Returns:
        +
        the new Single that emits the zipped results
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, source4 + source5 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
+        @NonNull SingleSource<? extends T2> source2,
+        @NonNull SingleSource<? extends T3> source3,
+        @NonNull SingleSource<? extends T4> source4,
+        @NonNull SingleSource<? extends T5> source5,
+        @NonNull SingleSource<? extends T6> source6,
+        @NonNull Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)
        +
        Returns a Single that emits the results of a specified combiner function applied to six items + emitted by six other SingleSources. +

        + +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the first source SingleSource's value type
        +
        T2 - the second source SingleSource's value type
        +
        T3 - the third source SingleSource's value type
        +
        T4 - the fourth source SingleSource's value type
        +
        T5 - the fifth source SingleSource's value type
        +
        T6 - the sixth source SingleSource's value type
        +
        R - the result value type
        +
        Parameters:
        +
        source1 - the first source SingleSource
        +
        source2 - a second source SingleSource
        +
        source3 - a third source SingleSource
        +
        source4 - a fourth source SingleSource
        +
        source5 - a fifth source SingleSource
        +
        source6 - a sixth source SingleSource
        +
        zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an + item that will be emitted by the resulting Single
        +
        Returns:
        +
        the new Single that emits the zipped results
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, source4 + source5, source6 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,T7,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
+        @NonNull SingleSource<? extends T2> source2,
+        @NonNull SingleSource<? extends T3> source3,
+        @NonNull SingleSource<? extends T4> source4,
+        @NonNull SingleSource<? extends T5> source5,
+        @NonNull SingleSource<? extends T6> source6,
+        @NonNull SingleSource<? extends T7> source7,
+        @NonNull Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)
        +
        Returns a Single that emits the results of a specified combiner function applied to seven items + emitted by seven other SingleSources. +

        + +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the first source SingleSource's value type
        +
        T2 - the second source SingleSource's value type
        +
        T3 - the third source SingleSource's value type
        +
        T4 - the fourth source SingleSource's value type
        +
        T5 - the fifth source SingleSource's value type
        +
        T6 - the sixth source SingleSource's value type
        +
        T7 - the seventh source SingleSource's value type
        +
        R - the result value type
        +
        Parameters:
        +
        source1 - the first source SingleSource
        +
        source2 - a second source SingleSource
        +
        source3 - a third source SingleSource
        +
        source4 - a fourth source SingleSource
        +
        source5 - a fifth source SingleSource
        +
        source6 - a sixth source SingleSource
        +
        source7 - a seventh source SingleSource
        +
        zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an + item that will be emitted by the resulting Single
        +
        Returns:
        +
        the new Single that emits the zipped results
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, source4 + source5, source6, source7 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,T7,T8,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
+        @NonNull SingleSource<? extends T2> source2,
+        @NonNull SingleSource<? extends T3> source3,
+        @NonNull SingleSource<? extends T4> source4,
+        @NonNull SingleSource<? extends T5> source5,
+        @NonNull SingleSource<? extends T6> source6,
+        @NonNull SingleSource<? extends T7> source7,
+        @NonNull SingleSource<? extends T8> source8,
+        @NonNull Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)
        +
        Returns a Single that emits the results of a specified combiner function applied to eight items + emitted by eight other SingleSources. +

        + +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the first source SingleSource's value type
        +
        T2 - the second source SingleSource's value type
        +
        T3 - the third source SingleSource's value type
        +
        T4 - the fourth source SingleSource's value type
        +
        T5 - the fifth source SingleSource's value type
        +
        T6 - the sixth source SingleSource's value type
        +
        T7 - the seventh source SingleSource's value type
        +
        T8 - the eighth source SingleSource's value type
        +
        R - the result value type
        +
        Parameters:
        +
        source1 - the first source SingleSource
        +
        source2 - a second source SingleSource
        +
        source3 - a third source SingleSource
        +
        source4 - a fourth source SingleSource
        +
        source5 - a fifth source SingleSource
        +
        source6 - a sixth source SingleSource
        +
        source7 - a seventh source SingleSource
        +
        source8 - an eighth source SingleSource
        +
        zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an + item that will be emitted by the resulting Single
        +
        Returns:
        +
        the new Single that emits the zipped results
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, source4 + source5, source6, source7, source8 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zip

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
+        @NonNull SingleSource<? extends T2> source2,
+        @NonNull SingleSource<? extends T3> source3,
+        @NonNull SingleSource<? extends T4> source4,
+        @NonNull SingleSource<? extends T5> source5,
+        @NonNull SingleSource<? extends T6> source6,
+        @NonNull SingleSource<? extends T7> source7,
+        @NonNull SingleSource<? extends T8> source8,
+        @NonNull SingleSource<? extends T9> source9,
+        @NonNull Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)
        +
        Returns a Single that emits the results of a specified combiner function applied to nine items + emitted by nine other SingleSources. +

        + +

        +
        Scheduler:
        +
        zip does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T1 - the first source SingleSource's value type
        +
        T2 - the second source SingleSource's value type
        +
        T3 - the third source SingleSource's value type
        +
        T4 - the fourth source SingleSource's value type
        +
        T5 - the fifth source SingleSource's value type
        +
        T6 - the sixth source SingleSource's value type
        +
        T7 - the seventh source SingleSource's value type
        +
        T8 - the eighth source SingleSource's value type
        +
        T9 - the ninth source SingleSource's value type
        +
        R - the result value type
        +
        Parameters:
        +
        source1 - the first source SingleSource
        +
        source2 - a second source SingleSource
        +
        source3 - a third source SingleSource
        +
        source4 - a fourth source SingleSource
        +
        source5 - a fifth source SingleSource
        +
        source6 - a sixth source SingleSource
        +
        source7 - a seventh source SingleSource
        +
        source8 - an eighth source SingleSource
        +
        source9 - a ninth source SingleSource
        +
        zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an + item that will be emitted by the resulting Single
        +
        Returns:
        +
        the new Single that emits the zipped results
        +
        Throws:
        +
        NullPointerException - if source1, source2, source3, source4 + source5, source6, source7, source8, + source9 or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + +
        +
      • +

        zipArray

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @SafeVarargs
+public static <T,R> @NonNull Single<R> zipArray(@NonNull Function<? super Object[],? extends R> zipper,
+        @NonNull SingleSource<? extends T>... sources)
        +
        Waits until all SingleSource sources provided via an array signal a success + value and calls a zipper function with an array of these values to return a result + to be emitted to downstream. +

        + +

        + If the array of SingleSources is empty a NoSuchElementException error is signaled immediately. +

        + Note on method signature: since Java doesn't allow creating a generic array with new T[], the + implementation of this operator has to create an Object[] instead. Unfortunately, a + Function<Integer[], R> passed to the method would trigger a ClassCastException. +

        + If any of the SingleSources signal an error, all other SingleSources get disposed and the + error emitted to downstream immediately. +

        +
        Scheduler:
        +
        zipArray does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the common value type
        +
        R - the result value type
        +
        Parameters:
        +
        sources - the array of SingleSource instances. An empty sequence will result in an + onError signal of NoSuchElementException.
        +
        zipper - the function that receives an array with values from each SingleSource + and should return a value to be emitted to downstream
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if zipper or sources is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        ambWith

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Single<T> ambWith(@NonNull SingleSource<? extends T> other)
        +
        Signals the event of this or the other SingleSource whichever signals first. +

        + +

        +
        Scheduler:
        +
        ambWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        other - the other SingleSource to race for the first emission of success or error
        +
        Returns:
        +
        the new Single instance. A subscription to this provided source will occur after subscribing + to the current source.
        +
        Throws:
        +
        NullPointerException - if other is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        cache

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Single<T> cache()
        +
        Stores the success value or exception from the current Single and replays it to late SingleObservers. +

        + +

        + The returned Single subscribes to the current Single when the first SingleObserver subscribes. +

        +
        Scheduler:
        +
        cache does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Single instance
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        delay

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Single<T> delay(long time,
+        @NonNull TimeUnit unit,
+        boolean delayError)
        +
        Delays the emission of the success or error signal from the current Single by the specified amount. +

        + +

        +
        Scheduler:
        +
        delay operates by default on the computation Scheduler.
        +
        +

        History: 2.1.5 - experimental

        +
        +
        Parameters:
        +
        time - the amount of time the success or error signal should be delayed for
        +
        unit - the time unit
        +
        delayError - if true, both success and error signals are delayed. if false, only success signals are delayed.
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + + + + + +
        +
      • +

        delay

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="custom")
+public final @NonNull Single<T> delay(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        boolean delayError)
        +
        Delays the emission of the success or error signal from the current Single by the specified amount. +

        + +

        +
        Scheduler:
        +
        you specify the Scheduler where the non-blocking wait and emission happens
        +
        +

        History: 2.1.5 - experimental

        +
        +
        Parameters:
        +
        time - the amount of time the success or error signal should be delayed for
        +
        unit - the time unit
        +
        scheduler - the target scheduler to use for the non-blocking wait and emission
        +
        delayError - if true, both success and error signals are delayed. if false, only success signals are delayed.
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if unit is null, or + if scheduler is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        delaySubscription

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Single<T> delaySubscription(@NonNull CompletableSource subscriptionIndicator)
        +
        Delays the actual subscription to the current Single until the given other CompletableSource + completes. +

        + +

        If the delaying source signals an error, that error is re-emitted and no subscription + to the current Single happens. +

        +
        Scheduler:
        +
        delaySubscription does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        subscriptionIndicator - the CompletableSource that has to complete before the subscription to the + current Single happens
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if subscriptionIndicator is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        delaySubscription

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final <U> @NonNull Single<T> delaySubscription(@NonNull SingleSource<U> subscriptionIndicator)
        +
        Delays the actual subscription to the current Single until the given other SingleSource + signals success. +

        + +

        If the delaying source signals an error, that error is re-emitted and no subscription + to the current Single happens. +

        +
        Scheduler:
        +
        delaySubscription does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the element type of the other source
        +
        Parameters:
        +
        subscriptionIndicator - the SingleSource that has to complete before the subscription to the + current Single happens
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if subscriptionIndicator is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        delaySubscription

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final <U> @NonNull Single<T> delaySubscription(@NonNull ObservableSource<U> subscriptionIndicator)
        +
        Delays the actual subscription to the current Single until the given other ObservableSource + signals its first value or completes. +

        + +

        If the delaying source signals an error, that error is re-emitted and no subscription + to the current Single happens. +

        +
        Scheduler:
        +
        delaySubscription does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the element type of the other source
        +
        Parameters:
        +
        subscriptionIndicator - the ObservableSource that has to signal a value or complete before the + subscription to the current Single happens
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if subscriptionIndicator is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        delaySubscription

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final <U> @NonNull Single<T> delaySubscription(@NonNull Publisher<U> subscriptionIndicator)
        +
        Delays the actual subscription to the current Single until the given other Publisher + signals its first value or completes. +

        + +

        If the delaying source signals an error, that error is re-emitted and no subscription + to the current Single happens. +

        The other source is consumed in an unbounded manner (requesting Long.MAX_VALUE from it). +

        +
        Backpressure:
        +
        The other publisher is consumed in an unbounded fashion but will be + cancelled after the first item it produced.
        +
        Scheduler:
        +
        delaySubscription does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the element type of the other source
        +
        Parameters:
        +
        subscriptionIndicator - the Publisher that has to signal a value or complete before the + subscription to the current Single happens
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if subscriptionIndicator is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        delaySubscription

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @NonNull
+public final @NonNull Single<T> delaySubscription(long time,
+        @NonNull TimeUnit unit)
        +
        Delays the actual subscription to the current Single until the given time delay elapsed. +

        + +

        +
        Scheduler:
        +
        delaySubscription does by default subscribe to the current Single + on the computation Scheduler after the delay.
        +
        +
        +
        Parameters:
        +
        time - the time amount to wait with the subscription
        +
        unit - the time unit of the waiting
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        delaySubscription

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Single<T> delaySubscription(long time,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Delays the actual subscription to the current Single until the given time delay elapsed. +

        + +

        +
        Scheduler:
        +
        delaySubscription does by default subscribe to the current Single + on the Scheduler you provided, after the delay.
        +
        +
        +
        Parameters:
        +
        time - the time amount to wait with the subscription
        +
        unit - the time unit of the waiting
        +
        scheduler - the Scheduler to wait on and subscribe on to the current Single
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        dematerialize

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Maybe<R> dematerialize(@NonNull Function<? super T,Notification<R>> selector)
        +
        Maps the Notification success value of the current Single back into normal + onSuccess, onError or onComplete signals as a + Maybe source. +

        + +

        + The intended use of the selector function is to perform a + type-safe identity mapping (see example) on a source that is already of type + Notification<T>. The Java language doesn't allow + limiting instance methods to a certain generic argument shape, therefore, + a function is used to ensure the conversion remains type safe. +

        +
        Scheduler:
        +
        dematerialize does not operate by default on a particular Scheduler.
        +
        +

        + Example: + 

        
+ Single.just(Notification.createOnNext(1))
+ .dematerialize(notification -> notification)
+ .test()
+ .assertResult(1);
+
        +

        History: 2.2.4 - experimental

        +
        +
        Type Parameters:
        +
        R - the result type
        +
        Parameters:
        +
        selector - the function called with the success item and should + return a Notification instance.
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if selector is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        materialize()
        +
        +
        • +
      + + + +
        +
      • +

        doAfterSuccess

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Single<T> doAfterSuccess(@NonNull Consumer<? super T> onAfterSuccess)
        +
        Calls the specified consumer with the success item after this item has been emitted to the downstream. +

        + +

        + Note that the doAfterSuccess action is shared between subscriptions and as such + should be thread-safe. +

        +
        Scheduler:
        +
        doAfterSuccess does not operate by default on a particular Scheduler.
        +
        +

        History: 2.0.1 - experimental

        +
        +
        Parameters:
        +
        onAfterSuccess - the Consumer that will be called after emitting an item from upstream to the downstream
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if onAfterSuccess is null
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + +
        +
      • +

        doAfterTerminate

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Single<T> doAfterTerminate(@NonNull Action onAfterTerminate)
        +
        Registers an Action to be called after this Single invokes either onSuccess or onError. +

        + +

        + Note that the doAfterTerminate action is shared between subscriptions and as such + should be thread-safe.

        + +
        +
        Scheduler:
        +
        doAfterTerminate does not operate by default on a particular Scheduler.
        +
        + +

        History: 2.0.6 - experimental

        +
        +
        Parameters:
        +
        onAfterTerminate - an Action to be invoked when the current Single finishes
        +
        Returns:
        +
        the new Single that emits the same items as the current Single, then invokes the + Action
        +
        Throws:
        +
        NullPointerException - if onAfterTerminate is null
        +
        Since:
        +
        2.1
        +
        See Also:
        +
        ReactiveX operators documentation: Do
        +
        +
        • +
      + + + +
        +
      • +

        doFinally

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Single<T> doFinally(@NonNull Action onFinally)
        +
        Calls the specified action after this Single signals onSuccess or onError or gets disposed by + the downstream. +

        In case of a race between a terminal event and a dispose call, the provided onFinally action + is executed once per subscription. +

        Note that the onFinally action is shared between subscriptions and as such + should be thread-safe. +

        + +

        +
        +
        Scheduler:
        +
        doFinally does not operate by default on a particular Scheduler.
        +
        +

        History: 2.0.1 - experimental

        +
        +
        Parameters:
        +
        onFinally - the action called when this Single terminates or gets disposed
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if onFinally is null
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final <U,R> @NonNull Single<R> flatMap(@NonNull Function<? super T,? extends SingleSource<? extends U>> mapper,
+        @NonNull BiFunction<? super T,? super U,? extends R> combiner)
        +
        Returns a Single that emits the results of a specified function to the pair of values emitted by the + current Single and a specified mapped SingleSource. +

        + +

        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the SingleSource returned by the mapper function
        +
        R - the type of items emitted by the resulting Single
        +
        Parameters:
        +
        mapper - a function that returns a SingleSource for the item emitted by the current Single
        +
        combiner - a function that combines one item emitted by each of the source and collection SingleSource and + returns an item to be emitted by the resulting SingleSource
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if mapper or combiner is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        ReactiveX operators documentation: FlatMap
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        blockingGet

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final T blockingGet()
        +
        Waits in a blocking fashion until the current Single signals a success value (which is returned) or + an exception (which is propagated). +

        + +

        +
        Scheduler:
        +
        blockingGet does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If the source signals an error, the operator wraps a checked Exception + into RuntimeException and throws that. Otherwise, RuntimeExceptions and + Errors are rethrown as they are.
        +
        +
        +
        Returns:
        +
        the success value
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        blockingSubscribe

        +
        @SchedulerSupport(value="none")
+public final void blockingSubscribe(@NonNull Consumer<? super T> onSuccess,
+        @NonNull Consumer<? super Throwable> onError)
        +
        Subscribes to the current Single and calls the appropriate callback on the current thread + when it terminates. +

        + +

        +
        Scheduler:
        +
        blockingSubscribe does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        If either onSuccess or onError throw, the Throwable is routed to the + global error handler via RxJavaPlugins.onError(Throwable). + If the current thread is interrupted, the onError consumer is called with an InterruptedException. +
        +
        +
        +
        Parameters:
        +
        onSuccess - the Consumer to call if the current Single succeeds
        +
        onError - the Consumer to call if the current Single signals an error
        +
        Throws:
        +
        NullPointerException - if onSuccess or onError is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        blockingSubscribe

        +
        @SchedulerSupport(value="none")
+public final void blockingSubscribe(@NonNull SingleObserver<? super T> observer)
        +
        Subscribes to the current Single and calls the appropriate SingleObserver method on the current thread. +

        + +

        +
        Scheduler:
        +
        blockingSubscribe does not operate by default on a particular Scheduler.
        +
        Error handling:
        +
        An onError signal is delivered to the SingleObserver.onError(Throwable) method. + If any of the SingleObserver's methods throw, the RuntimeException is propagated to the caller of this method. + If the current thread is interrupted, an InterruptedException is delivered to observer.onError. +
        +
        +
        +
        Parameters:
        +
        observer - the SingleObserver to call methods on the current thread
        +
        Throws:
        +
        NullPointerException - if observer is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        lift

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Single<R> lift(@NonNull SingleOperator<? extends R,? super T> lift)
        +
        This method requires advanced knowledge about building operators, please consider + other standard composition methods first; + Returns a Single which, when subscribed to, invokes the apply(SingleObserver) method + of the provided SingleOperator for each individual downstream Single and allows the + insertion of a custom operator by accessing the downstream's SingleObserver during this subscription phase + and providing a new SingleObserver, containing the custom operator's intended business logic, that will be + used in the subscription process going further upstream. +

        + +

        + Generally, such a new SingleObserver will wrap the downstream's SingleObserver and forwards the + onSuccess and onError events from the upstream directly or according to the + emission pattern the custom operator's business logic requires. In addition, such operator can intercept the + flow control calls of dispose and isDisposed that would have traveled upstream and perform + additional actions depending on the same business logic requirements. +

        + Example: + 

        
+ // Step 1: Create the consumer type that will be returned by the SingleOperator.apply():
+
+ public final class CustomSingleObserver<T> implements SingleObserver<T>, Disposable {
+
+     // The downstream's SingleObserver that will receive the onXXX events
+     final SingleObserver<? super String> downstream;
+
+     // The connection to the upstream source that will call this class' onXXX methods
+     Disposable upstream;
+
+     // The constructor takes the downstream subscriber and usually any other parameters
+     public CustomSingleObserver(SingleObserver<? super String> downstream) {
+         this.downstream = downstream;
+     }
+
+     // In the subscription phase, the upstream sends a Disposable to this class
+     // and subsequently this class has to send a Disposable to the downstream.
+     // Note that relaying the upstream's Disposable directly is not allowed in RxJava
+     @Override
+     public void onSubscribe(Disposable d) {
+         if (upstream != null) {
+             d.dispose();
+         } else {
+             upstream = d;
+             downstream.onSubscribe(this);
+         }
+     }
+
+     // The upstream calls this with the next item and the implementation's
+     // responsibility is to emit an item to the downstream based on the intended
+     // business logic, or if it can't do so for the particular item,
+        // request more from the upstream
+     @Override
+     public void onSuccess(T item) {
+         String str = item.toString();
+         if (str.length() < 2) {
+             downstream.onSuccess(str);
+         } else {
+             // Single is usually expected to produce one of the onXXX events
+             downstream.onError(new NoSuchElementException());
+         }
+     }
+
+     // Some operators may handle the upstream's error while others
+     // could just forward it to the downstream.
+     @Override
+     public void onError(Throwable throwable) {
+         downstream.onError(throwable);
+     }
+
+     // Some operators may use their own resources which should be cleaned up if
+     // the downstream disposes the flow before it completed. Operators without
+     // resources can simply forward the dispose to the upstream.
+     // In some cases, a disposed flag may be set by this method so that other parts
+     // of this class may detect the dispose and stop sending events
+     // to the downstream.
+     @Override
+     public void dispose() {
+         upstream.dispose();
+     }
+
+     // Some operators may simply forward the call to the upstream while others
+     // can return the disposed flag set in dispose().
+     @Override
+     public boolean isDisposed() {
+         return upstream.isDisposed();
+     }
+ }
+
+ // Step 2: Create a class that implements the SingleOperator interface and
+ //         returns the custom consumer type from above in its apply() method.
+ //         Such class may define additional parameters to be submitted to
+ //         the custom consumer type.
+
+ final class CustomSingleOperator<T> implements SingleOperator<String> {
+     @Override
+     public SingleObserver<? super String> apply(SingleObserver<? super T> upstream) {
+         return new CustomSingleObserver<T>(upstream);
+     }
+ }
+
+ // Step 3: Apply the custom operator via lift() in a flow by creating an instance of it
+ //         or reusing an existing one.
+
+ Single.just(5)
+ .lift(new CustomSingleOperator<Integer>())
+ .test()
+ .assertResult("5");
+
+ Single.just(15)
+ .lift(new CustomSingleOperator<Integer>())
+ .test()
+ .assertFailure(NoSuchElementException.class);
+
        +

        + Creating custom operators can be complicated and it is recommended one consults the + RxJava wiki: Writing operators page about + the tools, requirements, rules, considerations and pitfalls of implementing them. +

        + Note that implementing custom operators via this lift() method adds slightly more overhead by requiring + an additional allocation and indirection per assembled flows. Instead, extending the abstract Single + class and creating a SingleTransformer with it is recommended. +

        + Note also that it is not possible to stop the subscription phase in lift() as the apply() method + requires a non-null SingleObserver instance to be returned, which is then unconditionally subscribed to + the current Single. For example, if the operator decided there is no reason to subscribe to the + upstream source because of some optimization possibility or a failure to prepare the operator, it still has to + return a SingleObserver that should immediately dispose the upstream's Disposable in its + onSubscribe method. Again, using a SingleTransformer and extending the Single is + a better option as subscribeActual(io.reactivex.rxjava3.core.SingleObserver<? super T>) can decide to not subscribe to its upstream after all. +

        +
        Scheduler:
        +
        lift does not operate by default on a particular Scheduler, however, the + SingleOperator may use a Scheduler to support its own asynchronous behavior.
        +
        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        lift - the SingleOperator that receives the downstream's SingleObserver and should return + a SingleObserver with custom behavior to be used as the consumer for the current + Single.
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if lift is null
        +
        See Also:
        +
        RxJava wiki: Writing operators, +compose(SingleTransformer)
        +
        +
        • +
      + + + +
        +
      • +

        map

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final <R> @NonNull Single<R> map(@NonNull Function<? super T,? extends R> mapper)
        +
        Returns a Single that applies a specified function to the item emitted by the current Single and + emits the result of this function application. +

        + +

        +
        Scheduler:
        +
        map does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result value type
        +
        Parameters:
        +
        mapper - a function to apply to the item emitted by the Single
        +
        Returns:
        +
        the new Single that emits the item from the current Single, transformed by the specified function
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Map
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        onErrorReturn

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Single<T> onErrorReturn(@NonNull Function<Throwable,? extends T> itemSupplier)
        +
        Ends the flow with a success item returned by a function for the Throwable error signaled by the current + Single instead of signaling the error via onError. +

        + +

        + By default, when a Single encounters an error that prevents it from emitting the expected item to its + subscriber, the Single invokes its subscriber's SingleObserver.onError(java.lang.Throwable) method, and then quits + without invoking any more of its observer's methods. The onErrorReturn method changes this + behavior. If you pass a function (resumeFunction) to a Single's onErrorReturn method, if + the original Single encounters an error, instead of invoking its observer's + SingleObserver.onError(java.lang.Throwable) method, it will instead emit the return value of resumeFunction. +

        + You can use this to prevent errors from propagating or to supply fallback data should errors be + encountered. +

        +
        Scheduler:
        +
        onErrorReturn does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        itemSupplier - a function that returns an item that the new Single will emit if the current Single encounters + an error
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if itemSupplier is null
        +
        See Also:
        +
        ReactiveX operators documentation: Catch
        +
        +
        • +
      + + + + + +
        +
      • +

        onErrorReturnItem

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Single<T> onErrorReturnItem(@NonNull T item)
        +
        Signals the specified value as success in case the current Single signals an error. +

        + +

        +
        Scheduler:
        +
        onErrorReturnItem does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        item - the value to signal if the current Single fails
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if item is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        onErrorResumeWith

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Single<T> onErrorResumeWith(@NonNull SingleSource<? extends T> fallback)
        +
        Resumes the flow with the given SingleSource when the current Single fails instead of + signaling the error via onError. +

        + +

        + By default, when a Single encounters an error that prevents it from emitting the expected item to + its SingleObserver, the Single invokes its SingleObserver's onError method, and then quits + without invoking any more of its SingleObserver's methods. The onErrorResumeWith method changes this + behavior. If you pass another Single (resumeSingleInCaseOfError) to a Single's + onErrorResumeWith method, if the original Single encounters an error, instead of invoking its + SingleObserver's onError method, it will instead relinquish control to resumeSingleInCaseOfError which + will invoke the SingleObserver's onSuccess method if it is able to do so. In such a case, + because no Single necessarily invokes onError, the SingleObserver may never know that an error + happened. +

        + You can use this to prevent errors from propagating or to supply fallback data should errors be + encountered. +

        +
        Scheduler:
        +
        onErrorResumeWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        fallback - a Single that will take control if source Single encounters an error.
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if fallback is null
        +
        See Also:
        +
        ReactiveX operators documentation: Catch
        +
        +
        • +
      + + + +
        +
      • +

        onErrorComplete

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Maybe<T> onErrorComplete()
        +
        Returns a Maybe instance that if the current Single emits an error, it will emit an onComplete + and swallow the throwable. +

        + +

        +
        Scheduler:
        +
        onErrorComplete does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        the new Maybe instance
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        onErrorComplete

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Maybe<T> onErrorComplete(@NonNull Predicate<? super Throwable> predicate)
        +
        Returns a Maybe instance that if this Single emits an error and the predicate returns + true, it will emit an onComplete and swallow the throwable. +

        + +

        +
        Scheduler:
        +
        onErrorComplete does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        predicate - the predicate to call when an Throwable is emitted which should return true + if the Throwable should be swallowed and replaced with an onComplete.
        +
        Returns:
        +
        the new Maybe instance
        +
        Throws:
        +
        NullPointerException - if predicate is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        onErrorResumeNext

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+public final @NonNull Single<T> onErrorResumeNext(@NonNull Function<? super Throwable,? extends SingleSource<? extends T>> fallbackSupplier)
        +
        Resumes the flow with a SingleSource returned for the failure Throwable of the current Single by a + function instead of signaling the error via onError. +

        + +

        + By default, when a Single encounters an error that prevents it from emitting the expected item to + its SingleObserver, the Single invokes its SingleObserver's onError method, and then quits + without invoking any more of its SingleObserver's methods. The onErrorResumeNext method changes this + behavior. If you pass a function that will return another Single (resumeFunctionInCaseOfError) to a Single's + onErrorResumeNext method, if the original Single encounters an error, instead of invoking its + SingleObserver's onError method, it will instead relinquish control to resumeSingleInCaseOfError which + will invoke the SingleObserver's onSuccess method if it is able to do so. In such a case, + because no Single necessarily invokes onError, the SingleObserver may never know that an error + happened. +

        + You can use this to prevent errors from propagating or to supply fallback data should errors be + encountered. +

        +
        Scheduler:
        +
        onErrorResumeNext does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        fallbackSupplier - a function that returns a SingleSource that will take control if source Single encounters an error.
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if fallbackSupplier is null
        +
        Since:
        +
        .20
        +
        See Also:
        +
        ReactiveX operators documentation: Catch
        +
        +
        • +
      + + + +
        +
      • +

        onTerminateDetach

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Single<T> onTerminateDetach()
        +
        Nulls out references to the upstream producer and downstream SingleObserver if + the sequence is terminated or downstream calls dispose(). +

        + +

        +
        Scheduler:
        +
        onTerminateDetach does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.5 - experimental

        +
        +
        Returns:
        +
        the new Single which nulls out references to the upstream producer and downstream SingleObserver if + the sequence is terminated or downstream calls dispose()
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        repeatWhen

        +
        @BackpressureSupport(value=FULL)
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Flowable<T> repeatWhen(@NonNull Function<? super Flowable<Object>,? extends Publisher<?>> handler)
        +
        Re-subscribes to the current Single if + the Publisher returned by the handler function signals a value in response to a + value signaled through the Flowable the handler receives. +

        + +

        +
        Backpressure:
        +
        The returned Flowable honors the backpressure of the downstream consumer. + The Publisher returned by the handler function is expected to honor backpressure as well.
        +
        Scheduler:
        +
        repeatWhen does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        handler - the function that is called with a Flowable that signals a value when the Single + signaled a success value and returns a Publisher that has to signal a value to + trigger a resubscription to the current Single, otherwise the terminal signal of + the Publisher will be the terminal signal of the sequence as well.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if handler is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        retry

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Single<T> retry(long times)
        +
        Repeatedly re-subscribe at most the specified times to the current Single + if it fails with an onError. +

        + +

        +
        Scheduler:
        +
        retry does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        times - the number of times to resubscribe if the current Single fails
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        IllegalArgumentException - if times is negative
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + + + +
        +
      • +

        retry

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Single<T> retry(long times,
+        @NonNull Predicate<? super Throwable> predicate)
        +
        Repeatedly re-subscribe at most times or until the predicate returns false, whichever happens first + if it fails with an onError. +

        + +

        +
        Scheduler:
        +
        retry does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.8 - experimental

        +
        +
        Parameters:
        +
        times - the number of times to resubscribe if the current Single fails
        +
        predicate - the predicate called with the failure Throwable + and should return true if a resubscription should happen
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if predicate is null
        +
        IllegalArgumentException - if times is negative
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        retryWhen

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Single<T> retryWhen(@NonNull Function<? super Flowable<Throwable>,? extends Publisher<?>> handler)
        +
        Re-subscribes to the current Single if and when the Publisher returned by the handler + function signals a value. +

        + +

        + If the Publisher signals an onComplete, the resulting Single will signal a NoSuchElementException. +

        + Note that the inner Publisher returned by the handler function should signal + either onNext, onError or onComplete in response to the received + Throwable to indicate the operator should retry or terminate. If the upstream to + the operator is asynchronous, signaling onNext followed by onComplete immediately may + result in the sequence to be completed immediately. Similarly, if this inner + Publisher signals onError or onComplete while the upstream is + active, the sequence is terminated with the same signal immediately. +

        + The following example demonstrates how to retry an asynchronous source with a delay: + 

        
+ Single.timer(1, TimeUnit.SECONDS)
+     .doOnSubscribe(s -> System.out.println("subscribing"))
+     .map(v -> { throw new RuntimeException(); })
+     .retryWhen(errors -> {
+         AtomicInteger counter = new AtomicInteger();
+         return errors
+                   .takeWhile(e -> counter.getAndIncrement() != 3)
+                   .flatMap(e -> {
+                       System.out.println("delay retry by " + counter.get() + " second(s)");
+                       return Flowable.timer(counter.get(), TimeUnit.SECONDS);
+                   });
+     })
+     .blockingGet();
+
        +
        +
        Scheduler:
        +
        retryWhen does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        handler - the function that receives a Flowable of the error the Single emits and should + return a Publisher that should signal a normal value (in response to the + throwable the Flowable emits) to trigger a resubscription or signal an error to + be the output of the resulting Single
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if handler is null
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        subscribe

        +
        @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Disposable subscribe(@NonNull Consumer<? super T> onSuccess,
+        @NonNull Consumer<? super Throwable> onError,
+        @NonNull DisposableContainer container)
        +
        Wraps the given onXXX callbacks into a Disposable SingleObserver, + adds it to the given DisposableContainer and ensures, that if the upstream + terminates or this particular Disposable is disposed, the SingleObserver is removed + from the given container. +

        + The SingleObserver will be removed after the callback for the terminal event has been invoked. +

        +
        Scheduler:
        +
        subscribe does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        onSuccess - the callback for upstream items
        +
        onError - the callback for an upstream error if any
        +
        container - the DisposableContainer (such as CompositeDisposable) to add and remove the + created Disposable SingleObserver
        +
        Returns:
        +
        the Disposable that allows disposing the particular subscription.
        +
        Throws:
        +
        NullPointerException - if onSuccess, onError + or container is null
        +
        Since:
        +
        3.1.0
        +
        +
        • +
      + + + + + + + +
        +
      • +

        subscribeActual

        +
        protected abstract void subscribeActual(@NonNull SingleObserver<? super T> observer)
        +
        Implement this method in subclasses to handle the incoming SingleObservers. +

        There is no need to call any of the plugin hooks on the current Single instance or + the SingleObserver; all hooks and basic safeguards have been + applied by subscribe(SingleObserver) before this method gets called.

        +
        +
        Parameters:
        +
        observer - the SingleObserver to handle, not null
        +
        +
        • +
      + + + + + +
        +
      • +

        subscribeWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <E extends SingleObserver<? super T>> E subscribeWith(E observer)
        +
        Subscribes a given SingleObserver (subclass) to this Single and returns the given + SingleObserver as is. +

        + +

        Usage example: + 

        
+ Single<Integer> source = Single.just(1);
+ CompositeDisposable composite = new CompositeDisposable();
+
+ DisposableSingleObserver<Integer> ds = new DisposableSingleObserver<>() {
+     // ...
+ };
+
+ composite.add(source.subscribeWith(ds));
+
        +
        +
        Scheduler:
        +
        subscribeWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        E - the type of the SingleObserver to use and return
        +
        Parameters:
        +
        observer - the SingleObserver (subclass) to use and return, not null
        +
        Returns:
        +
        the input observer
        +
        Throws:
        +
        NullPointerException - if observer is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + + + +
        +
      • +

        timeInterval

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="io.reactivex:computation")
+public final @NonNull Single<Timed<T>> timeInterval()
        +
        Measures the time (in milliseconds) between the subscription and success item emission + of the current Single and signals it as a tuple (Timed) + success value. +

        + +

        + If the current Single fails, the resulting Single will + pass along the signal to the downstream. To measure the time to error, + use materialize() and apply timeInterval(). +

        +
        Scheduler:
        +
        timeInterval uses the computation Scheduler + for determining the current time upon subscription and upon receiving the + success item from the current Single.
        +
        +
        +
        Returns:
        +
        the new Single instance
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        timeInterval

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="custom")
+public final @NonNull Single<Timed<T>> timeInterval(@NonNull Scheduler scheduler)
        +
        Measures the time (in milliseconds) between the subscription and success item emission + of the current Single and signals it as a tuple (Timed) + success value. +

        + +

        + If the current Single fails, the resulting Single will + pass along the signal to the downstream. To measure the time to error, + use materialize() and apply timeInterval(Scheduler). +

        +
        Scheduler:
        +
        timeInterval uses the provided Scheduler + for determining the current time upon subscription and upon receiving the + success item from the current Single.
        +
        +
        +
        Parameters:
        +
        scheduler - the Scheduler used for providing the current time
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if scheduler is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        timeInterval

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="io.reactivex:computation")
+public final @NonNull Single<Timed<T>> timeInterval(@NonNull TimeUnit unit)
        +
        Measures the time between the subscription and success item emission + of the current Single and signals it as a tuple (Timed) + success value. +

        + +

        + If the current Single fails, the resulting Single will + pass along the signals to the downstream. To measure the time to error, + use materialize() and apply timeInterval(TimeUnit, Scheduler). +

        +
        Scheduler:
        +
        timeInterval uses the computation Scheduler + for determining the current time upon subscription and upon receiving the + success item from the current Single.
        +
        +
        +
        Parameters:
        +
        unit - the time unit for measurement
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        timeInterval

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="custom")
+public final @NonNull Single<Timed<T>> timeInterval(@NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Measures the time between the subscription and success item emission + of the current Single and signals it as a tuple (Timed) + success value. +

        + +

        + If the current Single is empty or fails, the resulting Single will + pass along the signals to the downstream. To measure the time to termination, + use materialize() and apply timeInterval(TimeUnit, Scheduler). +

        +
        Scheduler:
        +
        timeInterval uses the provided Scheduler + for determining the current time upon subscription and upon receiving the + success item from the current Single.
        +
        +
        +
        Parameters:
        +
        unit - the time unit for measurement
        +
        scheduler - the Scheduler used for providing the current time
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        timestamp

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="io.reactivex:computation")
+public final @NonNull Single<Timed<T>> timestamp()
        +
        Combines the success value from the current Single with the current time (in milliseconds) of + its reception, using the computation Scheduler as time source, + then signals them as a Timed instance. +

        + +

        + If the current Single is empty or fails, the resulting Single will + pass along the signals to the downstream. To get the timestamp of the error, + use materialize() and apply timestamp(). +

        +
        Scheduler:
        +
        timestamp uses the computation Scheduler + for determining the current time upon receiving the + success item from the current Single.
        +
        +
        +
        Returns:
        +
        the new Single instance
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        timestamp

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="custom")
+public final @NonNull Single<Timed<T>> timestamp(@NonNull Scheduler scheduler)
        +
        Combines the success value from the current Single with the current time (in milliseconds) of + its reception, using the given Scheduler as time source, + then signals them as a Timed instance. +

        + +

        + If the current Single is empty or fails, the resulting Single will + pass along the signals to the downstream. To get the timestamp of the error, + use materialize() and apply timestamp(Scheduler). +

        +
        Scheduler:
        +
        timestamp uses the provided Scheduler + for determining the current time upon receiving the + success item from the current Single.
        +
        +
        +
        Parameters:
        +
        scheduler - the Scheduler used for providing the current time
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if scheduler is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        timestamp

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="io.reactivex:computation")
+public final @NonNull Single<Timed<T>> timestamp(@NonNull TimeUnit unit)
        +
        Combines the success value from the current Single with the current time of + its reception, using the computation Scheduler as time source, + then signals it as a Timed instance. +

        + +

        + If the current Single is empty or fails, the resulting Single will + pass along the signals to the downstream. To get the timestamp of the error, + use materialize() and apply timestamp(TimeUnit). +

        +
        Scheduler:
        +
        timestamp uses the computation Scheduler, + for determining the current time upon receiving the + success item from the current Single.
        +
        +
        +
        Parameters:
        +
        unit - the time unit for measurement
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        timestamp

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="custom")
+public final @NonNull Single<Timed<T>> timestamp(@NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Combines the success value from the current Single with the current time of + its reception, using the given Scheduler as time source, + then signals it as a Timed instance. +

        + +

        + If the current Single is empty or fails, the resulting Single will + pass along the signals to the downstream. To get the timestamp of the error, + use materialize() and apply timestamp(TimeUnit, Scheduler). +

        +
        Scheduler:
        +
        timestamp uses the provided Scheduler, + which is used for determining the current time upon receiving the + success item from the current Single.
        +
        +
        +
        Parameters:
        +
        unit - the time unit for measurement
        +
        scheduler - the Scheduler used for providing the current time
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="custom")
+public final @NonNull Single<T> timeout(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        @NonNull SingleSource<? extends T> fallback)
        +
        Runs the current Single and if it doesn't signal within the specified timeout window, it is + disposed and the other SingleSource subscribed to. +

        + +

        +
        Scheduler:
        +
        timeout subscribes to the other SingleSource on the Scheduler you specify.
        +
        +
        +
        Parameters:
        +
        timeout - the timeout amount
        +
        unit - the time unit
        +
        scheduler - the Scheduler where the timeout is awaited and the subscription to other happens
        +
        fallback - the other SingleSource that gets subscribed to if the current Single times out
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if unit, scheduler or fallback is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        timeout

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="io.reactivex:computation")
+public final @NonNull Single<T> timeout(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull SingleSource<? extends T> fallback)
        +
        Runs the current Single and if it doesn't signal within the specified timeout window, it is + disposed and the other SingleSource subscribed to. +

        + +

        +
        Scheduler:
        +
        timeout subscribes to the other SingleSource on + the computation Scheduler.
        +
        +
        +
        Parameters:
        +
        timeout - the timeout amount
        +
        unit - the time unit
        +
        fallback - the other SingleSource that gets subscribed to if the current Single times out
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if fallback or unit is null
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        to

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+public final <R> R to(@NonNull SingleConverter<T,? extends R> converter)
        +
        Calls the specified converter function during assembly time and returns its resulting value. +

        + +

        + This allows fluent conversion to any other type. +

        +
        Scheduler:
        +
        to does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.7 - experimental

        +
        +
        Type Parameters:
        +
        R - the resulting object type
        +
        Parameters:
        +
        converter - the function that receives the current Single instance and returns a value
        +
        Returns:
        +
        the converted value
        +
        Throws:
        +
        NullPointerException - if converter is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        zipWith

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <U,R> @NonNull Single<R> zipWith(@NonNull SingleSource<U> other,
+        @NonNull BiFunction<? super T,? super U,? extends R> zipper)
        +
        Returns a Single that emits the result of applying a specified function to the pair of items emitted by + the current Single and another specified SingleSource. +

        + +

        +
        Scheduler:
        +
        zipWith does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the type of items emitted by the other Single
        +
        R - the type of items emitted by the resulting Single
        +
        Parameters:
        +
        other - the other SingleSource
        +
        zipper - a function that combines the pairs of items from the two SingleSources to generate the items to + be emitted by the resulting Single
        +
        Returns:
        +
        the new Single that pairs up values from the current Single and the other SingleSource + and emits the results of zipFunction applied to these pairs
        +
        Throws:
        +
        NullPointerException - if other or zipper is null
        +
        See Also:
        +
        ReactiveX operators documentation: Zip
        +
        +
        • +
      + + + + + + + +
        +
      • +

        test

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull TestObserver<T> test(boolean dispose)
        +
        Creates a TestObserver optionally in cancelled state, then subscribes it to this Single. +

        + +

        +
        Scheduler:
        +
        test does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        dispose - if true, the TestObserver will be cancelled before subscribing to this + Single.
        +
        Returns:
        +
        the new TestObserver instance
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + +
        +
      • +

        fromCompletionStage

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public static <T> @NonNull Single<T> fromCompletionStage(@NonNull CompletionStage<T> stage)
        +
        Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation. +

        + +

        + Note that the operator takes an already instantiated, running or terminated CompletionStage. + If the CompletionStage is to be created per consumer upon subscription, use defer(Supplier) + around fromCompletionStage: + 

        
+ Single.defer(() -> Single.fromCompletionStage(createCompletionStage()));
+
        +

        + If the CompletionStage completes with null, the resulting Single is terminated with + a NullPointerException. +

        + Canceling the flow can't cancel the execution of the CompletionStage because CompletionStage + itself doesn't support cancellation. Instead, the operator detaches from the CompletionStage. +

        +
        Scheduler:
        +
        fromCompletionStage does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the element type of the CompletionStage
        +
        Parameters:
        +
        stage - the CompletionStage to convert to Single and signal its success value or error
        +
        Returns:
        +
        the new Single instance
        +
        Throws:
        +
        NullPointerException - if stage is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        flattenStreamAsFlowable

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=FULL)
+ @NonNull
+public final <R> @NonNull Flowable<R> flattenStreamAsFlowable(@NonNull Function<? super T,? extends Stream<? extends R>> mapper)
        +
        Maps the upstream succecss value into a Java Stream and emits its + items to the downstream consumer as a Flowable. + +

        + The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when + closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). + If a Stream should not be closed, turn it into an Iterable and use flattenAsFlowable(Function): + 

        
+ source.flattenAsFlowable(item -> createStream(item)::iterator);
+
        +

        + Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): + 

        
+ source.flattenStreamAsFlowable(item -> IntStream.rangeClosed(1, 10).boxed());
+
        +

        + Stream does not support concurrent usage so creating and/or consuming the same instance multiple times + from multiple threads can lead to undefined behavior. +

        +
        Backpressure:
        +
        The operator honors backpressure from downstream and iterates the given Stream + on demand (i.e., when requested).
        +
        Scheduler:
        +
        flattenStreamAsFlowable does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the Stream and the output Flowable
        +
        Parameters:
        +
        mapper - the function that receives the upstream success item and should + return a Stream of values to emit.
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        flattenAsFlowable(Function), +flattenStreamAsObservable(Function)
        +
        +
        • +
      + + + +
        +
      • +

        flattenStreamAsObservable

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull Observable<R> flattenStreamAsObservable(@NonNull Function<? super T,? extends Stream<? extends R>> mapper)
        +
        Maps the upstream succecss value into a Java Stream and emits its + items to the downstream consumer as an Observable. +

        + +

        + The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when + closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). + If a Stream should not be closed, turn it into an Iterable and use flattenAsObservable(Function): + 

        
+ source.flattenAsObservable(item -> createStream(item)::iterator);
+
        +

        + Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): + 

        
+ source.flattenStreamAsObservable(item -> IntStream.rangeClosed(1, 10).boxed());
+
        +

        + Stream does not support concurrent usage so creating and/or consuming the same instance multiple times + from multiple threads can lead to undefined behavior. +

        +
        Scheduler:
        +
        flattenStreamAsObservable does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the Stream and the output Observable
        +
        Parameters:
        +
        mapper - the function that receives the upstream success item and should + return a Stream of values to emit.
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        flattenAsObservable(Function), +flattenStreamAsFlowable(Function)
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleConverter.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleConverter.html new file mode 100644 index 0000000000..02697d9ea0 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleConverter.html @@ -0,0 +1,245 @@ + + + + + +SingleConverter (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface SingleConverter<T,R>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the upstream type
    +
    R - the output type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface SingleConverter<T,R>
    +
    Convenience interface and callback used by the Single.to(io.reactivex.rxjava3.core.SingleConverter<T, ? extends R>) operator to turn a Single into another + value fluently. +

    History: 2.1.7 - experimental

    +
    +
    Since:
    +
    2.2
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        apply

        +
        R apply(@NonNull
+        @NonNull Single<T> upstream)
        +
        Applies a function to the upstream Single and returns a converted value of type R.
        +
        +
        Parameters:
        +
        upstream - the upstream Single instance
        +
        Returns:
        +
        the converted value
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleEmitter.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleEmitter.html new file mode 100644 index 0000000000..290cfc2cec --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleEmitter.html @@ -0,0 +1,386 @@ + + + + + +SingleEmitter (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface SingleEmitter<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type to emit
    +
    +
    +
    +
    public interface SingleEmitter<T>
    +
    Abstraction over an RxJava SingleObserver that allows associating + a resource with it. +

    + All methods are safe to call from multiple threads, but note that there is no guarantee + whose terminal event will win and get delivered to the downstream. +

    + Calling onSuccess(Object) multiple times has no effect. + Calling onError(Throwable) multiple times or after onSuccess will route the + exception into the global error handler via RxJavaPlugins.onError(Throwable). +

    + The emitter allows the registration of a single resource, in the form of a Disposable + or Cancellable via setDisposable(Disposable) or setCancellable(Cancellable) + respectively. The emitter implementations will dispose/cancel this instance when the + downstream cancels the flow or after the event generator logic calls onSuccess(Object), + onError(Throwable), or when tryOnError(Throwable) succeeds. +

    + Only one Disposable or Cancellable object can be associated with the emitter at + a time. Calling either set method will dispose/cancel any previous object. If there + is a need for handling multiple resources, one can create a CompositeDisposable + and associate that with the emitter instead. +

    + The Cancellable is logically equivalent to Disposable but allows using cleanup logic that can + throw a checked exception (such as many close() methods on Java IO components). Since + the release of resources happens after the terminal events have been delivered or the sequence gets + cancelled, exceptions throw within Cancellable are routed to the global error handler via + RxJavaPlugins.onError(Throwable).

    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        onSuccess

        +
        void onSuccess(@NonNull
+               T t)
        +
        Signal a success value.
        +
        +
        Parameters:
        +
        t - the value, not null
        +
        +
        • +
      + + + +
        +
      • +

        onError

        +
        void onError(@NonNull
+             @NonNull Throwable t)
        +
        Signal an exception.
        +
        +
        Parameters:
        +
        t - the exception, not null
        +
        +
        • +
      + + + +
        +
      • +

        setDisposable

        +
        void setDisposable(@Nullable
+                   @Nullable Disposable d)
        +
        Sets a Disposable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled. +

        This method is thread-safe.

        +
        +
        Parameters:
        +
        d - the Disposable, null is allowed
        +
        +
        • +
      + + + +
        +
      • +

        setCancellable

        +
        void setCancellable(@Nullable
+                    @Nullable Cancellable c)
        +
        Sets a Cancellable on this emitter; any previous Disposable + or Cancellable will be disposed/cancelled. +

        This method is thread-safe.

        +
        +
        Parameters:
        +
        c - the Cancellable resource, null is allowed
        +
        +
        • +
      + + + +
        +
      • +

        isDisposed

        +
        boolean isDisposed()
        +
        Returns true if the downstream disposed the sequence or the + emitter was terminated via onSuccess(Object), onError(Throwable), + or a successful tryOnError(Throwable). +

        This method is thread-safe.

        +
        +
        Returns:
        +
        true if the downstream disposed the sequence or the emitter was terminated
        +
        +
        • +
      + + + +
        +
      • +

        tryOnError

        +
        boolean tryOnError(@NonNull
+                   @NonNull Throwable t)
        +
        Attempts to emit the specified Throwable error if the downstream + hasn't cancelled the sequence or is otherwise terminated, returning false + if the emission is not allowed to happen due to lifecycle restrictions. +

        + Unlike onError(Throwable), the RxjavaPlugins.onError + is not called if the error could not be delivered. +

        History: 2.1.1 - experimental

        +
        +
        Parameters:
        +
        t - the throwable error to signal if possible
        +
        Returns:
        +
        true if successful, false if the downstream is not able to accept further + events
        +
        Since:
        +
        2.2
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleObserver.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleObserver.html new file mode 100644 index 0000000000..0b251a9c10 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleObserver.html @@ -0,0 +1,325 @@ + + + + + +SingleObserver (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface SingleObserver<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the type of item the SingleObserver expects to observe
    +
    +
    +
    All Known Implementing Classes:
    +
    DisposableSingleObserver, ResourceSingleObserver, SingleSubject, TestObserver
    +
    +
    +
    +
    public interface SingleObserver<T>
    +
    Provides a mechanism for receiving push-based notification of a single value or an error. +

    + When a SingleObserver is subscribed to a SingleSource through the SingleSource.subscribe(SingleObserver) method, + the SingleSource calls onSubscribe(Disposable) with a Disposable that allows + disposing the sequence at any time. A well-behaved + SingleSource will call a SingleObserver's onSuccess(Object) method exactly once or the SingleObserver's + onError(java.lang.Throwable) method exactly once as they are considered mutually exclusive terminal signals. +

    + Calling the SingleObserver's method must happen in a serialized fashion, that is, they must not + be invoked concurrently by multiple threads in an overlapping fashion and the invocation pattern must + adhere to the following protocol: + 

        onSubscribe (onSuccess | onError)?
    +

    + Subscribing a SingleObserver to multiple SingleSources is not recommended. If such reuse + happens, it is the duty of the SingleObserver implementation to be ready to receive multiple calls to + its methods and ensure proper concurrent behavior of its business logic. +

    + Calling onSubscribe(Disposable), onSuccess(Object) or onError(Throwable) with a + null argument is forbidden. +

    + The implementations of the onXXX methods should avoid throwing runtime exceptions other than the following cases: +

      +
    • If the argument is null, the methods can throw a NullPointerException. + Note though that RxJava prevents nulls to enter into the flow and thus there is generally no + need to check for nulls in flows assembled from standard sources and intermediate operators. +
      • +
    • If there is a fatal error (such as VirtualMachineError).
      • +
    +
    +
    Since:
    +
    2.0
    +
    See Also:
    +
    ReactiveX documentation: Observable
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        onSubscribe

        +
        void onSubscribe(@NonNull
+                 @NonNull Disposable d)
        +
        Provides the SingleObserver with the means of cancelling (disposing) the + connection (channel) with the Single in both + synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.
        +
        +
        Parameters:
        +
        d - the Disposable instance whose Disposable.dispose() can + be called anytime to cancel the connection
        +
        Since:
        +
        2.0
        +
        +
        • +
      + + + + + +
        +
      • +

        onSuccess

        +
        void onSuccess(@NonNull
+               T t)
        +
        Notifies the SingleObserver with a single item and that the Single has finished sending + push-based notifications. +

        + The Single will not call this method if it calls onError(java.lang.Throwable).

        +
        +
        Parameters:
        +
        t - the item emitted by the Single
        +
        +
        • +
      + + + +
        +
      • +

        onError

        +
        void onError(@NonNull
+             @NonNull Throwable e)
        +
        Notifies the SingleObserver that the Single has experienced an error condition. +

        + If the Single calls this method, it will not thereafter call onSuccess(T).

        +
        +
        Parameters:
        +
        e - the exception encountered by the Single
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleOnSubscribe.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleOnSubscribe.html new file mode 100644 index 0000000000..5d51ae4599 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleOnSubscribe.html @@ -0,0 +1,241 @@ + + + + + +SingleOnSubscribe (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface SingleOnSubscribe<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type pushed
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface SingleOnSubscribe<T>
    +
    A functional interface that has a subscribe() method that receives + a SingleEmitter instance that allows pushing + an event in a cancellation-safe manner.
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleOperator.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleOperator.html new file mode 100644 index 0000000000..a8b2883c85 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleOperator.html @@ -0,0 +1,243 @@ + + + + + +SingleOperator (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface SingleOperator<Downstream,Upstream>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    Downstream - the value type of the downstream
    +
    Upstream - the value type of the upstream
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface SingleOperator<Downstream,Upstream>
    +
    Interface to map/wrap a downstream SingleObserver to an upstream SingleObserver.
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleSource.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleSource.html new file mode 100644 index 0000000000..c0ef4af112 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleSource.html @@ -0,0 +1,250 @@ + + + + + +SingleSource (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface SingleSource<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the element type
    +
    +
    +
    All Known Implementing Classes:
    +
    Single, SingleSubject
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface SingleSource<T>
    +
    Represents a basic Single source base interface, + consumable via an SingleObserver. +

    + This class also serves the base type for custom operators wrapped into + Single via Single.create(SingleOnSubscribe).

    +
    +
    Since:
    +
    2.0
    +
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleTransformer.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleTransformer.html new file mode 100644 index 0000000000..bd0960da5d --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/SingleTransformer.html @@ -0,0 +1,242 @@ + + + + + +SingleTransformer (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.core
+

Interface SingleTransformer<Upstream,Downstream>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    Upstream - the upstream value type
    +
    Downstream - the downstream value type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface SingleTransformer<Upstream,Downstream>
    +
    Interface to compose Singles.
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/package-frame.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/package-frame.html new file mode 100644 index 0000000000..02ac511a13 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/package-frame.html @@ -0,0 +1,69 @@ + + + + + +io.reactivex.rxjava3.core (RxJava Javadoc 3.1.8) + + + + +

io.reactivex.rxjava3.core

+
+

Interfaces

+ +

Classes

+ +

Enums

+ +
+ + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/package-summary.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/package-summary.html new file mode 100644 index 0000000000..ca9a7d6320 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/package-summary.html @@ -0,0 +1,516 @@ + + + + + +io.reactivex.rxjava3.core (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Package io.reactivex.rxjava3.core

+
+
Base reactive classes: Flowable, Observable, + Single, Maybe and + Completable; base reactive consumers; + other common base interfaces.
+
+

See: Description

+
+
+ + + + +

Package io.reactivex.rxjava3.core Description

+
Base reactive classes: Flowable, Observable, + Single, Maybe and + Completable; base reactive consumers; + other common base interfaces. + +

A library that enables subscribing to and composing asynchronous events and + callbacks.

+

The Flowable/Subscriber, Observable/Observer, Single/SingleObserver and + Completable/CompletableObserver interfaces and associated operators (in + the io.reactivex.internal.operators package) are inspired by the + Reactive Rx library in Microsoft .NET but designed and implemented on + the more advanced Reactive-Streams ( http://www.reactivestreams.org ) principles.

+

+ More information can be found at http://msdn.microsoft.com/en-us/data/gg577609. +

+ + +

Compared with the Microsoft implementation: +

    +
  • Observable == IObservable (base type)
    • +
  • Observer == IObserver (event consumer)
    • +
  • Disposable == IDisposable (resource/cancellation management)
    • +
  • Observable == Observable (factory methods)
    • +
  • Flowable == IAsyncEnumerable (backpressure)
    • +
  • Subscriber == IAsyncEnumerator
    • +
+ The Single and Completable reactive base types have no equivalent in Rx.NET as of 3.x. + +

Services which intend on exposing data asynchronously and wish + to allow reactive processing and composition can implement the + Flowable, Observable, Single, + Maybe or Completable class which then allow + consumers to subscribe to them and receive events.

+

Usage examples can be found on the Flowable/Observable and Subscriber classes.

+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/package-tree.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/package-tree.html new file mode 100644 index 0000000000..b620c968f8 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/core/package-tree.html @@ -0,0 +1,199 @@ + + + + + +io.reactivex.rxjava3.core Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For Package io.reactivex.rxjava3.core

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +

Interface Hierarchy

+ +

Enum Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/CompositeDisposable.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/CompositeDisposable.html new file mode 100644 index 0000000000..717846910c --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/CompositeDisposable.html @@ -0,0 +1,511 @@ + + + + + +CompositeDisposable (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.disposables
+

Class CompositeDisposable

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CompositeDisposable

        +
        public CompositeDisposable()
        +
        Creates an empty CompositeDisposable.
        +
        • +
      + + + +
        +
      • +

        CompositeDisposable

        +
        public CompositeDisposable(@NonNull
+                           Disposable... disposables)
        +
        Creates a CompositeDisposable with the given array of initial Disposable elements.
        +
        +
        Parameters:
        +
        disposables - the array of Disposables to start with
        +
        Throws:
        +
        NullPointerException - if disposables or any of its array items is null
        +
        +
        • +
      + + + +
        +
      • +

        CompositeDisposable

        +
        public CompositeDisposable(@NonNull
+                           @NonNull Iterable<? extends Disposable> disposables)
        +
        Creates a CompositeDisposable with the given Iterable sequence of initial Disposable elements.
        +
        +
        Parameters:
        +
        disposables - the Iterable sequence of Disposable to start with
        +
        Throws:
        +
        NullPointerException - if disposables or any of its items is null
        +
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        dispose

        +
        public void dispose()
        +
        Description copied from interface: Disposable
        +
        Dispose the resource, the operation should be idempotent.
        +
        +
        Specified by:
        +
        dispose in interface Disposable
        +
        +
        • +
      + + + +
        +
      • +

        isDisposed

        +
        public boolean isDisposed()
        +
        Description copied from interface: Disposable
        +
        Returns true if this resource has been disposed.
        +
        +
        Specified by:
        +
        isDisposed in interface Disposable
        +
        Returns:
        +
        true if this resource has been disposed
        +
        +
        • +
      + + + +
        +
      • +

        add

        +
        public boolean add(@NonNull
+                   @NonNull Disposable disposable)
        +
        Adds a Disposable to this container or disposes it if the + container has been disposed.
        +
        +
        Specified by:
        +
        add in interface DisposableContainer
        +
        Parameters:
        +
        disposable - the Disposable to add, not null
        +
        Returns:
        +
        true if successful, false if this container has been disposed
        +
        Throws:
        +
        NullPointerException - if disposable is null
        +
        +
        • +
      + + + +
        +
      • +

        addAll

        +
        public boolean addAll(@NonNull
+                      Disposable... disposables)
        +
        Atomically adds the given array of Disposables to the container or + disposes them all if the container has been disposed.
        +
        +
        Parameters:
        +
        disposables - the array of Disposables
        +
        Returns:
        +
        true if the operation was successful, false if the container has been disposed
        +
        Throws:
        +
        NullPointerException - if disposables or any of its array items is null
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        clear

        +
        public void clear()
        +
        Atomically clears the container, then disposes all the previously contained Disposables.
        +
        • +
      + + + +
        +
      • +

        size

        +
        public int size()
        +
        Returns the number of currently held Disposables.
        +
        +
        Returns:
        +
        the number of currently held Disposables
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/Disposable.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/Disposable.html new file mode 100644 index 0000000000..f895cd7fa2 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/Disposable.html @@ -0,0 +1,506 @@ + + + + + +Disposable (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.disposables
+

Interface Disposable

+
+
+
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        dispose

        +
        void dispose()
        +
        Dispose the resource, the operation should be idempotent.
        +
        • +
      + + + +
        +
      • +

        isDisposed

        +
        boolean isDisposed()
        +
        Returns true if this resource has been disposed.
        +
        +
        Returns:
        +
        true if this resource has been disposed
        +
        +
        • +
      + + + +
        +
      • +

        fromRunnable

        +
        @NonNull
+static @NonNull Disposable fromRunnable(@NonNull Runnable run)
        +
        Construct a Disposable by wrapping a Runnable that is + executed exactly once when the Disposable is disposed.
        +
        +
        Parameters:
        +
        run - the Runnable to wrap
        +
        Returns:
        +
        the new Disposable instance
        +
        Throws:
        +
        NullPointerException - if run is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        fromAction

        +
        @NonNull
+static @NonNull Disposable fromAction(@NonNull Action action)
        +
        Construct a Disposable by wrapping a Action that is + executed exactly once when the Disposable is disposed.
        +
        +
        Parameters:
        +
        action - the Action to wrap
        +
        Returns:
        +
        the new Disposable instance
        +
        Throws:
        +
        NullPointerException - if action is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + + + + + +
        +
      • +

        fromFuture

        +
        @NonNull
+static @NonNull Disposable fromFuture(@NonNull Future<?> future,
+        boolean allowInterrupt)
        +
        Construct a Disposable by wrapping a Future that is + cancelled exactly once when the Disposable is disposed.
        +
        +
        Parameters:
        +
        future - the Future to wrap
        +
        allowInterrupt - if true, the future cancel happens via Future.cancel(true)
        +
        Returns:
        +
        the new Disposable instance
        +
        Throws:
        +
        NullPointerException - if future is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        fromSubscription

        +
        @NonNull
+static @NonNull Disposable fromSubscription(@NonNull Subscription subscription)
        +
        Construct a Disposable by wrapping a Subscription that is + cancelled exactly once when the Disposable is disposed.
        +
        +
        Parameters:
        +
        subscription - the Runnable to wrap
        +
        Returns:
        +
        the new Disposable instance
        +
        Throws:
        +
        NullPointerException - if subscription is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        fromAutoCloseable

        +
        @NonNull
+static @NonNull Disposable fromAutoCloseable(@NonNull AutoCloseable autoCloseable)
        +
        Construct a Disposable by wrapping an AutoCloseable that is + closed exactly once when the Disposable is disposed.
        +
        +
        Parameters:
        +
        autoCloseable - the AutoCloseable to wrap
        +
        Returns:
        +
        the new Disposable instance
        +
        Throws:
        +
        NullPointerException - if autoCloseable is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + + + + + +
        +
      • +

        empty

        +
        @NonNull
+static @NonNull Disposable empty()
        +
        Returns a new, non-disposed Disposable instance.
        +
        +
        Returns:
        +
        a new, non-disposed Disposable instance
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        disposed

        +
        @NonNull
+static @NonNull Disposable disposed()
        +
        Returns a shared, disposed Disposable instance.
        +
        +
        Returns:
        +
        a shared, disposed Disposable instance
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/DisposableContainer.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/DisposableContainer.html new file mode 100644 index 0000000000..96dc265e12 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/DisposableContainer.html @@ -0,0 +1,286 @@ + + + + + +DisposableContainer (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.disposables
+

Interface DisposableContainer

+
+
+
+
    +
  • +
    +
    All Known Implementing Classes:
    +
    CompositeDisposable
    +
    +
    +
    +
    public interface DisposableContainer
    +
    Common interface to add and remove disposables from a container.
    +
    +
    Since:
    +
    2.0
    +
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Abstract Methods 
      Modifier and TypeMethod and Description
      booleanadd(Disposable d) +
      Adds a disposable to this container or disposes it if the + container has been disposed.
      +
      booleandelete(Disposable d) +
      Removes but does not dispose the given disposable if it is part of this + container.
      +
      booleanremove(Disposable d) +
      Removes and disposes the given disposable if it is part of this + container.
      +
      +
      • +
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        add

        +
        boolean add(Disposable d)
        +
        Adds a disposable to this container or disposes it if the + container has been disposed.
        +
        +
        Parameters:
        +
        d - the disposable to add, not null
        +
        Returns:
        +
        true if successful, false if this container has been disposed
        +
        +
        • +
      + + + +
        +
      • +

        remove

        +
        boolean remove(Disposable d)
        +
        Removes and disposes the given disposable if it is part of this + container.
        +
        +
        Parameters:
        +
        d - the disposable to remove and dispose, not null
        +
        Returns:
        +
        true if the operation was successful
        +
        +
        • +
      + + + +
        +
      • +

        delete

        +
        boolean delete(Disposable d)
        +
        Removes but does not dispose the given disposable if it is part of this + container.
        +
        +
        Parameters:
        +
        d - the disposable to remove, not null
        +
        Returns:
        +
        true if the operation was successful
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/SerialDisposable.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/SerialDisposable.html new file mode 100644 index 0000000000..6a5b882057 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/SerialDisposable.html @@ -0,0 +1,412 @@ + + + + + +SerialDisposable (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.disposables
+

Class SerialDisposable

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Disposable
    +
    +
    +
    +
    public final class SerialDisposable
+extends Object
+implements Disposable
    +
    A Disposable container that allows atomically updating/replacing the contained + Disposable with another Disposable, disposing the old one when updating plus + handling the disposition when the container itself is disposed.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SerialDisposable

        +
        public SerialDisposable()
        +
        Constructs an empty SerialDisposable.
        +
        • +
      + + + +
        +
      • +

        SerialDisposable

        +
        public SerialDisposable(@Nullable
+                        @Nullable Disposable initialDisposable)
        +
        Constructs a SerialDisposable with the given initial Disposable instance.
        +
        +
        Parameters:
        +
        initialDisposable - the initial Disposable instance to use, null allowed
        +
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        set

        +
        public boolean set(@Nullable
+                   @Nullable Disposable next)
        +
        Atomically: set the next disposable on this container and dispose the previous + one (if any) or dispose next if the container has been disposed.
        +
        +
        Parameters:
        +
        next - the Disposable to set, may be null
        +
        Returns:
        +
        true if the operation succeeded, false if the container has been disposed
        +
        See Also:
        +
        replace(Disposable)
        +
        +
        • +
      + + + +
        +
      • +

        replace

        +
        public boolean replace(@Nullable
+                       @Nullable Disposable next)
        +
        Atomically: set the next disposable on this container but don't dispose the previous + one (if any) or dispose next if the container has been disposed.
        +
        +
        Parameters:
        +
        next - the Disposable to set, may be null
        +
        Returns:
        +
        true if the operation succeeded, false if the container has been disposed
        +
        See Also:
        +
        set(Disposable)
        +
        +
        • +
      + + + +
        +
      • +

        get

        +
        @Nullable
+public @Nullable Disposable get()
        +
        Returns the currently contained Disposable or null if this container is empty.
        +
        +
        Returns:
        +
        the current Disposable, may be null
        +
        +
        • +
      + + + +
        +
      • +

        dispose

        +
        public void dispose()
        +
        Description copied from interface: Disposable
        +
        Dispose the resource, the operation should be idempotent.
        +
        +
        Specified by:
        +
        dispose in interface Disposable
        +
        +
        • +
      + + + +
        +
      • +

        isDisposed

        +
        public boolean isDisposed()
        +
        Description copied from interface: Disposable
        +
        Returns true if this resource has been disposed.
        +
        +
        Specified by:
        +
        isDisposed in interface Disposable
        +
        Returns:
        +
        true if this resource has been disposed
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/package-frame.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/package-frame.html new file mode 100644 index 0000000000..6cd0638f1f --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/package-frame.html @@ -0,0 +1,25 @@ + + + + + +io.reactivex.rxjava3.disposables (RxJava Javadoc 3.1.8) + + + + +

io.reactivex.rxjava3.disposables

+
+

Interfaces

+ +

Classes

+ +
+ + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/package-summary.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/package-summary.html new file mode 100644 index 0000000000..566d184cc1 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/package-summary.html @@ -0,0 +1,187 @@ + + + + + +io.reactivex.rxjava3.disposables (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Package io.reactivex.rxjava3.disposables

+
+
Default implementations for Disposable-based resource management + (Disposable container types) and utility classes to construct + Disposables from callbacks and other types.
+
+

See: Description

+
+
+ + + + +

Package io.reactivex.rxjava3.disposables Description

+
Default implementations for Disposable-based resource management + (Disposable container types) and utility classes to construct + Disposables from callbacks and other types.
+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/package-tree.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/package-tree.html new file mode 100644 index 0000000000..ad2b095aa3 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/disposables/package-tree.html @@ -0,0 +1,140 @@ + + + + + +io.reactivex.rxjava3.disposables Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For Package io.reactivex.rxjava3.disposables

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +

Interface Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/CompositeException.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/CompositeException.html new file mode 100644 index 0000000000..2f448cea4b --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/CompositeException.html @@ -0,0 +1,472 @@ + + + + + +CompositeException (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.exceptions
+

Class CompositeException

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Serializable
    +
    +
    +
    +
    public final class CompositeException
+extends RuntimeException
    +
    Represents an exception that is a composite of one or more other exceptions. A CompositeException + does not modify the structure of any exception it wraps, but at print-time it iterates through the list of + Throwables contained in the composite in order to print them all. + + Its invariant is to contain an immutable, ordered (by insertion order), unique list of non-composite + exceptions. You can retrieve individual exceptions in this list with getExceptions(). + + The printStackTrace() implementation handles the StackTrace in a customized way instead of using + getCause() so that it can avoid circular references. + + If you invoke getCause(), it will lazily create the causal chain but will stop if it finds any + Throwable in the chain that it has already seen.
    +
    +
    See Also:
    +
    Serialized Form
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        CompositeException

        +
        public CompositeException(@NonNull
+                          Throwable... exceptions)
        +
        Constructs a CompositeException with the given array of Throwables as the + list of suppressed exceptions.
        +
        +
        Parameters:
        +
        exceptions - the Throwables to have as initially suppressed exceptions
        +
        Throws:
        +
        IllegalArgumentException - if exceptions is empty.
        +
        +
        • +
      + + + +
        +
      • +

        CompositeException

        +
        public CompositeException(@NonNull
+                          @NonNull Iterable<? extends Throwable> errors)
        +
        Constructs a CompositeException with the given array of Throwables as the + list of suppressed exceptions.
        +
        +
        Parameters:
        +
        errors - the Throwables to have as initially suppressed exceptions
        +
        Throws:
        +
        IllegalArgumentException - if errors is empty.
        +
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        getExceptions

        +
        @NonNull
+public @NonNull List<Throwable> getExceptions()
        +
        Retrieves the list of exceptions that make up the CompositeException.
        +
        +
        Returns:
        +
        the exceptions that make up the CompositeException, as a List of Throwables
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        printStackTrace

        +
        public void printStackTrace()
        +
        All of the following printStackTrace functionality is derived from JDK Throwable + printStackTrace. In particular, the PrintStreamOrWriter abstraction is copied wholesale. + + Changes from the official JDK implementation:
          +
        • no infinite loop detection
          • +
        • smaller critical section holding PrintStream lock
          • +
        • explicit knowledge about the exceptions List that this loops through
          • +
        +
        +
        Overrides:
        +
        printStackTrace in class Throwable
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        size

        +
        public int size()
        +
        Returns the number of suppressed exceptions.
        +
        +
        Returns:
        +
        the number of suppressed exceptions
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/Exceptions.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/Exceptions.html new file mode 100644 index 0000000000..80a93ac9cd --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/Exceptions.html @@ -0,0 +1,283 @@ + + + + + +Exceptions (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.exceptions
+

Class Exceptions

+
+
+ +
+
    +
  • +
    +
    +
    public final class Exceptions
+extends Object
    +
    Utility class to help propagate checked exceptions and rethrow exceptions + designated as fatal.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        propagate

        +
        @NonNull
+public static @NonNull RuntimeException propagate(@NonNull
+                                                           @NonNull Throwable t)
        +
        Convenience method to throw a RuntimeException and Error directly + or wrap any other exception type into a RuntimeException.
        +
        +
        Parameters:
        +
        t - the exception to throw directly or wrapped
        +
        Returns:
        +
        because propagate itself throws an exception or error, this is a sort of phantom return + value; propagate does not actually return anything
        +
        +
        • +
      + + + +
        +
      • +

        throwIfFatal

        +
        public static void throwIfFatal(@NonNull
+                                @NonNull Throwable t)
        +
        Throws a particular Throwable only if it belongs to a set of "fatal" error varieties. These + varieties are as follows: +
          +
        • VirtualMachineError
          • +
        • ThreadDeath
          • +
        • LinkageError
          • +
        + This can be useful if you are writing an operator that calls user-supplied code, and you want to + notify subscribers of errors encountered in that code by calling their onError methods, but only + if the errors are not so catastrophic that such a call would be futile, in which case you simply want to + rethrow the error.
        +
        +
        Parameters:
        +
        t - the Throwable to test and perhaps throw
        +
        See Also:
        +
        RxJava: StackOverflowError is swallowed (Issue #748)
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/MissingBackpressureException.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/MissingBackpressureException.html new file mode 100644 index 0000000000..f757f2da1c --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/MissingBackpressureException.html @@ -0,0 +1,380 @@ + + + + + +MissingBackpressureException (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + +
+
io.reactivex.rxjava3.exceptions
+

Class MissingBackpressureException

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Serializable
    +
    +
    +
    +
    public final class MissingBackpressureException
+extends RuntimeException
    +
    Indicates that an operator attempted to emit a value but the downstream wasn't ready for it.
    +
    +
    See Also:
    +
    Serialized Form
    +
    +
    • +
+
+
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        MissingBackpressureException

        +
        public MissingBackpressureException()
        +
        Constructs a MissingBackpressureException without message or cause.
        +
        • +
      + + + +
        +
      • +

        MissingBackpressureException

        +
        public MissingBackpressureException(String message)
        +
        Constructs a MissingBackpressureException with the given message but no cause.
        +
        +
        Parameters:
        +
        message - the error message
        +
        +
        • +
      +
      • +
    + + +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/OnErrorNotImplementedException.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/OnErrorNotImplementedException.html new file mode 100644 index 0000000000..892793fd81 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/OnErrorNotImplementedException.html @@ -0,0 +1,307 @@ + + + + + +OnErrorNotImplementedException (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.exceptions
+

Class OnErrorNotImplementedException

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Serializable
    +
    +
    +
    +
    public final class OnErrorNotImplementedException
+extends RuntimeException
    +
    Represents an exception used to signal to the RxJavaPlugins.onError() that a + callback-based subscribe() method on a base reactive type didn't specify + an onError handler. +

    History: 2.0.6 - experimental; 2.1 - beta

    +
    +
    Since:
    +
    2.2
    +
    See Also:
    +
    Serialized Form
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        OnErrorNotImplementedException

        +
        public OnErrorNotImplementedException(String message,
+                                      @NonNull
+                                      @NonNull Throwable e)
        +
        Customizes the Throwable with a custom message and wraps it before it + is signalled to the RxJavaPlugins.onError() handler as OnErrorNotImplementedException.
        +
        +
        Parameters:
        +
        message - the message to assign to the Throwable to signal
        +
        e - the Throwable to signal; if null, a NullPointerException is constructed
        +
        +
        • +
      + + + +
        +
      • +

        OnErrorNotImplementedException

        +
        public OnErrorNotImplementedException(@NonNull
+                                      @NonNull Throwable e)
        +
        Wraps the Throwable before it + is signalled to the RxJavaPlugins.onError() + handler as OnErrorNotImplementedException.
        +
        +
        Parameters:
        +
        e - the Throwable to signal; if null, a NullPointerException is constructed
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/ProtocolViolationException.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/ProtocolViolationException.html new file mode 100644 index 0000000000..fee609d0e9 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/ProtocolViolationException.html @@ -0,0 +1,281 @@ + + + + + +ProtocolViolationException (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.exceptions
+

Class ProtocolViolationException

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Serializable
    +
    +
    +
    +
    public final class ProtocolViolationException
+extends IllegalStateException
    +
    Explicitly named exception to indicate a Reactive-Streams + protocol violation. +

    History: 2.0.6 - experimental; 2.1 - beta

    +
    +
    Since:
    +
    2.2
    +
    See Also:
    +
    Serialized Form
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ProtocolViolationException

        +
        public ProtocolViolationException(String message)
        +
        Creates an instance with the given message.
        +
        +
        Parameters:
        +
        message - the message
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/QueueOverflowException.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/QueueOverflowException.html new file mode 100644 index 0000000000..ea7fb07006 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/QueueOverflowException.html @@ -0,0 +1,291 @@ + + + + + +QueueOverflowException (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.exceptions
+

Class QueueOverflowException

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    Serializable
    +
    +
    +
    +
    public final class QueueOverflowException
+extends RuntimeException
    +
    Indicates an overflow happened because the upstream disregarded backpressure completely or + Subscriber.onNext(Object) was called concurrently from multiple threads + without synchronization. Rarely, it is an indication of bugs inside an operator.
    +
    +
    Since:
    +
    3.1.6
    +
    See Also:
    +
    Serialized Form
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        QueueOverflowException

        +
        public QueueOverflowException()
        +
        Constructs a QueueOverflowException with the default message.
        +
        • +
      + + + +
        +
      • +

        QueueOverflowException

        +
        public QueueOverflowException(String message)
        +
        Constructs a QueueOverflowException with the given message but no cause.
        +
        +
        Parameters:
        +
        message - the error message
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/UndeliverableException.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/UndeliverableException.html new file mode 100644 index 0000000000..5d51903f6d --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/UndeliverableException.html @@ -0,0 +1,282 @@ + + + + + +UndeliverableException (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.exceptions
+

Class UndeliverableException

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        UndeliverableException

        +
        public UndeliverableException(Throwable cause)
        +
        Construct an instance by wrapping the given, non-null + cause Throwable.
        +
        +
        Parameters:
        +
        cause - the cause, not null
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/package-frame.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/package-frame.html new file mode 100644 index 0000000000..1905eb444b --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/package-frame.html @@ -0,0 +1,28 @@ + + + + + +io.reactivex.rxjava3.exceptions (RxJava Javadoc 3.1.8) + + + + +

io.reactivex.rxjava3.exceptions

+
+

Classes

+ +

Exceptions

+ +
+ + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/package-summary.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/package-summary.html new file mode 100644 index 0000000000..850df18b75 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/package-summary.html @@ -0,0 +1,211 @@ + + + + + +io.reactivex.rxjava3.exceptions (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Package io.reactivex.rxjava3.exceptions

+
+
Exception handling utilities (Exceptions), + composite exception container (CompositeException) and + various lifecycle-related (UndeliverableException) + and behavior-violation exception types (OnErrorNotImplementedException, + MissingBackpressureException).
+
+

See: Description

+
+
+ + + + +

Package io.reactivex.rxjava3.exceptions Description

+
Exception handling utilities (Exceptions), + composite exception container (CompositeException) and + various lifecycle-related (UndeliverableException) + and behavior-violation exception types (OnErrorNotImplementedException, + MissingBackpressureException).
+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/package-tree.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/package-tree.html new file mode 100644 index 0000000000..234546bce6 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/exceptions/package-tree.html @@ -0,0 +1,156 @@ + + + + + +io.reactivex.rxjava3.exceptions Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For Package io.reactivex.rxjava3.exceptions

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/ConnectableFlowable.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/ConnectableFlowable.html new file mode 100644 index 0000000000..922fe89a4c --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/ConnectableFlowable.html @@ -0,0 +1,821 @@ + + + + + +ConnectableFlowable (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.flowables
+

Class ConnectableFlowable<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the type of items emitted by the ConnectableFlowable
    +
    +
    +
    All Implemented Interfaces:
    +
    Publisher<T>
    +
    +
    +
    +
    public abstract class ConnectableFlowable<T>
+extends Flowable<T>
    +
    A ConnectableFlowable resembles an ordinary Flowable, except that it does not begin + emitting items when it is subscribed to, but only when its connect(io.reactivex.rxjava3.functions.Consumer<? super io.reactivex.rxjava3.disposables.Disposable>) method is called. In this way you + can wait for all intended Subscribers to Flowable.subscribe() to the Flowable + before the Flowable begins emitting items. +

    + +

    + When the upstream terminates, the ConnectableFlowable remains in this terminated state and, + depending on the actual underlying implementation, relays cached events to late Subscribers. + In order to reuse and restart this ConnectableFlowable, the reset() method has to be called. + When called, this ConnectableFlowable will appear as fresh, unconnected source to new Subscribers. + Disposing the connection will reset the ConnectableFlowable to its fresh state and there is no need to call + reset() in this case. +

    + Note that although connect() and reset() are safe to call from multiple threads, it is recommended + a dedicated thread or business logic manages the connection or resetting of a ConnectableFlowable so that + there is no unwanted signal loss due to early connect() or reset() calls while Subscribers are + still being subscribed to to this ConnectableFlowable to receive signals from the get go. +

    +
    +
    Since:
    +
    2.0.0
    +
    See Also:
    +
    RxJava Wiki: Connectable Observable Operators
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ConnectableFlowable

        +
        public ConnectableFlowable()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        connect

        +
        @SchedulerSupport(value="none")
+public abstract void connect(@NonNull Consumer<? super Disposable> connection)
        +
        Instructs the ConnectableFlowable to begin emitting the items from its underlying + Flowable to its Subscribers. +
        +
        Scheduler:
        +
        The behavior is determined by the implementor of this abstract class.
        +
        +
        +
        Parameters:
        +
        connection - the action that receives the connection subscription before the subscription to source happens + allowing the caller to synchronously disconnect a synchronous source
        +
        Throws:
        +
        NullPointerException - if connection is null
        +
        See Also:
        +
        ReactiveX documentation: Connect
        +
        +
        • +
      + + + +
        +
      • +

        reset

        +
        @SchedulerSupport(value="none")
+public abstract void reset()
        +
        Resets this ConnectableFlowable into its fresh state if it has terminated. +

        + Calling this method on a fresh or active ConnectableFlowable has no effect. +

        +
        Scheduler:
        +
        The behavior is determined by the implementor of this abstract class.
        +
        +
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        refCount

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=PASS_THROUGH)
+ @NonNull
+public final @NonNull Flowable<T> refCount(int subscriberCount)
        +
        Connects to the upstream ConnectableFlowable if the number of subscribed + subscriber reaches the specified count and disconnect if all subscribers have unsubscribed. +
        +
        Backpressure:
        +
        The operator itself doesn't interfere with backpressure which is determined by the upstream + ConnectableFlowable's backpressure behavior.
        +
        Scheduler:
        +
        This refCount overload does not operate on any particular Scheduler.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        subscriberCount - the number of subscribers required to connect to the upstream
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if subscriberCount is non-positive
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        refCount

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @BackpressureSupport(value=PASS_THROUGH)
+ @NonNull
+public final @NonNull Flowable<T> refCount(long timeout,
+        @NonNull TimeUnit unit)
        +
        Connects to the upstream ConnectableFlowable if the number of subscribed + subscriber reaches 1 and disconnect after the specified + timeout if all subscribers have unsubscribed. +
        +
        Backpressure:
        +
        The operator itself doesn't interfere with backpressure which is determined by the upstream + ConnectableFlowable's backpressure behavior.
        +
        Scheduler:
        +
        This refCount overload operates on the computation Scheduler.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        timeout - the time to wait before disconnecting after all subscribers unsubscribed
        +
        unit - the time unit of the timeout
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        refCount(long, TimeUnit, Scheduler)
        +
        +
        • +
      + + + +
        +
      • +

        refCount

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @BackpressureSupport(value=PASS_THROUGH)
+ @NonNull
+public final @NonNull Flowable<T> refCount(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Connects to the upstream ConnectableFlowable if the number of subscribed + subscriber reaches 1 and disconnect after the specified + timeout if all subscribers have unsubscribed. +
        +
        Backpressure:
        +
        The operator itself doesn't interfere with backpressure which is determined by the upstream + ConnectableFlowable's backpressure behavior.
        +
        Scheduler:
        +
        This refCount overload operates on the specified Scheduler.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        timeout - the time to wait before disconnecting after all subscribers unsubscribed
        +
        unit - the time unit of the timeout
        +
        scheduler - the target scheduler to wait on before disconnecting
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        refCount

        +
        @CheckReturnValue
+ @SchedulerSupport(value="io.reactivex:computation")
+ @BackpressureSupport(value=PASS_THROUGH)
+ @NonNull
+public final @NonNull Flowable<T> refCount(int subscriberCount,
+        long timeout,
+        @NonNull TimeUnit unit)
        +
        Connects to the upstream ConnectableFlowable if the number of subscribed + subscriber reaches the specified count and disconnect after the specified + timeout if all subscribers have unsubscribed. +
        +
        Backpressure:
        +
        The operator itself doesn't interfere with backpressure which is determined by the upstream + ConnectableFlowable's backpressure behavior.
        +
        Scheduler:
        +
        This refCount overload operates on the computation Scheduler.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        subscriberCount - the number of subscribers required to connect to the upstream
        +
        timeout - the time to wait before disconnecting after all subscribers unsubscribed
        +
        unit - the time unit of the timeout
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit is null
        +
        IllegalArgumentException - if subscriberCount is non-positive
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        refCount(int, long, TimeUnit, Scheduler)
        +
        +
        • +
      + + + +
        +
      • +

        refCount

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @BackpressureSupport(value=PASS_THROUGH)
+ @NonNull
+public final @NonNull Flowable<T> refCount(int subscriberCount,
+        long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Connects to the upstream ConnectableFlowable if the number of subscribed + subscriber reaches the specified count and disconnect after the specified + timeout if all subscribers have unsubscribed. +
        +
        Backpressure:
        +
        The operator itself doesn't interfere with backpressure which is determined by the upstream + ConnectableFlowable's backpressure behavior.
        +
        Scheduler:
        +
        This refCount overload operates on the specified Scheduler.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        subscriberCount - the number of subscribers required to connect to the upstream
        +
        timeout - the time to wait before disconnecting after all subscribers unsubscribed
        +
        unit - the time unit of the timeout
        +
        scheduler - the target scheduler to wait on before disconnecting
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if subscriberCount is non-positive
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        autoConnect

        +
        @NonNull
+ @CheckReturnValue
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public @NonNull Flowable<T> autoConnect()
        +
        Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable + when the first Subscriber subscribes. +

        + +

        + The connection happens after the first subscription and happens at most once + during the lifetime of the returned Flowable. If this ConnectableFlowable + terminates, the connection is never renewed, no matter how Subscribers come + and go. Use refCount() to renew a connection or dispose an active + connection when all Subscribers have cancelled their Subscriptions. +

        + This overload does not allow disconnecting the connection established via + connect(Consumer). Use the autoConnect(int, Consumer) overload + to gain access to the Disposable representing the only connection. +

        +
        Backpressure:
        +
        The operator itself doesn't interfere with backpressure which is determined by + the upstream ConnectableFlowable's behavior.
        +
        Scheduler:
        +
        autoConnect does not operate by default on a particular Scheduler.
        +
        +
        +
        Returns:
        +
        a new Flowable instance that automatically connects to this ConnectableFlowable + when the first Subscriber subscribes
        +
        See Also:
        +
        refCount(), +autoConnect(int, Consumer)
        +
        +
        • +
      + + + +
        +
      • +

        autoConnect

        +
        @NonNull
+ @CheckReturnValue
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public @NonNull Flowable<T> autoConnect(int numberOfSubscribers)
        +
        Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable + when the specified number of Subscribers subscribe to it. +

        + +

        + The connection happens after the given number of subscriptions and happens at most once + during the lifetime of the returned Flowable. If this ConnectableFlowable + terminates, the connection is never renewed, no matter how Subscribers come + and go. Use refCount() to renew a connection or dispose an active + connection when all Subscribers have cancelled their Subscriptions. +

        + This overload does not allow disconnecting the connection established via + connect(Consumer). Use the autoConnect(int, Consumer) overload + to gain access to the Disposable representing the only connection. +

        +
        Backpressure:
        +
        The operator itself doesn't interfere with backpressure which is determined by + the upstream ConnectableFlowable's behavior.
        +
        Scheduler:
        +
        autoConnect does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        numberOfSubscribers - the number of subscribers to await before calling connect + on the ConnectableFlowable. A non-positive value indicates + an immediate connection.
        +
        Returns:
        +
        a new Flowable instance that automatically connects to this ConnectableFlowable + when the specified number of Subscribers subscribe to it
        +
        +
        • +
      + + + +
        +
      • +

        autoConnect

        +
        @NonNull
+ @CheckReturnValue
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public @NonNull Flowable<T> autoConnect(int numberOfSubscribers,
+        @NonNull Consumer<? super Disposable> connection)
        +
        Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable + when the specified number of Subscribers subscribe to it and calls the + specified callback with the Disposable associated with the established connection. +

        + +

        + The connection happens after the given number of subscriptions and happens at most once + during the lifetime of the returned Flowable. If this ConnectableFlowable + terminates, the connection is never renewed, no matter how Subscribers come + and go. Use refCount() to renew a connection or dispose an active + connection when all Subscribers have cancelled their Subscriptions. +

        +
        Backpressure:
        +
        The operator itself doesn't interfere with backpressure which is determined by + the upstream ConnectableFlowable's behavior.
        +
        Scheduler:
        +
        autoConnect does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        numberOfSubscribers - the number of subscribers to await before calling connect + on the ConnectableFlowable. A non-positive value indicates + an immediate connection.
        +
        connection - the callback Consumer that will receive the Disposable representing the + established connection
        +
        Returns:
        +
        a new Flowable instance that automatically connects to this ConnectableFlowable + when the specified number of Subscribers subscribe to it and calls the + specified callback with the Disposable associated with the established connection
        +
        Throws:
        +
        NullPointerException - if connection is null
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/GroupedFlowable.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/GroupedFlowable.html new file mode 100644 index 0000000000..efd2937da1 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/GroupedFlowable.html @@ -0,0 +1,320 @@ + + + + + +GroupedFlowable (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.flowables
+

Class GroupedFlowable<K,T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    K - the type of the key
    +
    T - the type of the items emitted by the GroupedFlowable
    +
    +
    +
    All Implemented Interfaces:
    +
    Publisher<T>
    +
    +
    +
    +
    public abstract class GroupedFlowable<K,T>
+extends Flowable<T>
    +
    A Flowable that has been grouped by key, the value of which can be obtained with getKey(). +

    + Note: A GroupedFlowable will cache the items it is to emit until such time as it + is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those + GroupedFlowables that do not concern you. Instead, you can signal to them that they + may discard their buffers by applying an operator like take(0) to them.

    +
    +
    See Also:
    +
    Flowable.groupBy(io.reactivex.rxjava3.functions.Function), +ReactiveX documentation: GroupBy
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        GroupedFlowable

        +
        protected GroupedFlowable(@Nullable
+                          K key)
        +
        Constructs a GroupedFlowable with the given key.
        +
        +
        Parameters:
        +
        key - the key
        +
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        getKey

        +
        @Nullable
+public K getKey()
        +
        Returns the key that identifies the group of items emitted by this GroupedFlowable.
        +
        +
        Returns:
        +
        the key that the items emitted by this GroupedFlowable were grouped by
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/package-frame.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/package-frame.html new file mode 100644 index 0000000000..be06ddf9f5 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/package-frame.html @@ -0,0 +1,20 @@ + + + + + +io.reactivex.rxjava3.flowables (RxJava Javadoc 3.1.8) + + + + +

io.reactivex.rxjava3.flowables

+
+

Classes

+ +
+ + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/package-summary.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/package-summary.html new file mode 100644 index 0000000000..58c7c11890 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/package-summary.html @@ -0,0 +1,161 @@ + + + + + +io.reactivex.rxjava3.flowables (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Package io.reactivex.rxjava3.flowables

+
+
Classes supporting the Flowable base reactive class: + ConnectableFlowable and + GroupedFlowable.
+
+

See: Description

+
+
+ + + + +

Package io.reactivex.rxjava3.flowables Description

+
Classes supporting the Flowable base reactive class: + ConnectableFlowable and + GroupedFlowable.
+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/package-tree.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/package-tree.html new file mode 100644 index 0000000000..08622cfb9d --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/flowables/package-tree.html @@ -0,0 +1,139 @@ + + + + + +io.reactivex.rxjava3.flowables Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For Package io.reactivex.rxjava3.flowables

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Action.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Action.html new file mode 100644 index 0000000000..274dab2a90 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Action.html @@ -0,0 +1,232 @@ + + + + + +Action (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface Action

+
+
+
+
    +
  • +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface Action
    +
    A functional interface similar to Runnable but allows throwing a checked exception.
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + +
      All Methods Instance Methods Abstract Methods 
      Modifier and TypeMethod and Description
      voidrun() +
      Runs the action and optionally throws a checked exception.
      +
      +
      • +
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        run

        +
        void run()
+  throws Throwable
        +
        Runs the action and optionally throws a checked exception.
        +
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BiConsumer.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BiConsumer.html new file mode 100644 index 0000000000..a8326aeac7 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BiConsumer.html @@ -0,0 +1,244 @@ + + + + + +BiConsumer (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface BiConsumer<T1,T2>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T1 - the first value type
    +
    T2 - the second value type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface BiConsumer<T1,T2>
    +
    A functional interface (callback) that accepts two values (of possibly different types).
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        accept

        +
        void accept(T1 t1,
+            T2 t2)
+     throws Throwable
        +
        Performs an operation on the given values.
        +
        +
        Parameters:
        +
        t1 - the first value
        +
        t2 - the second value
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BiFunction.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BiFunction.html new file mode 100644 index 0000000000..b6b2d012f6 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BiFunction.html @@ -0,0 +1,251 @@ + + + + + +BiFunction (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface BiFunction<T1,T2,R>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T1 - the first value type
    +
    T2 - the second value type
    +
    R - the result type
    +
    +
    +
    All Known Implementing Classes:
    +
    ParallelFailureHandling
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface BiFunction<T1,T2,R>
    +
    A functional interface (callback) that computes a value based on multiple input values.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        apply

        +
        R apply(T1 t1,
+        T2 t2)
+ throws Throwable
        +
        Calculate a value based on the input values.
        +
        +
        Parameters:
        +
        t1 - the first value
        +
        t2 - the second value
        +
        Returns:
        +
        the result value
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BiPredicate.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BiPredicate.html new file mode 100644 index 0000000000..c549c6ddeb --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BiPredicate.html @@ -0,0 +1,248 @@ + + + + + +BiPredicate (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface BiPredicate<T1,T2>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T1 - the first value
    +
    T2 - the second value
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface BiPredicate<T1,T2>
    +
    A functional interface (callback) that returns true or false for the given input values.
    +
    • +
+
+
+
    +
  • + + +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        test

        +
        boolean test(@NonNull
+             T1 t1,
+             @NonNull
+             T2 t2)
+      throws Throwable
        +
        Test the given input values and return a boolean.
        +
        +
        Parameters:
        +
        t1 - the first value
        +
        t2 - the second value
        +
        Returns:
        +
        the boolean result
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BooleanSupplier.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BooleanSupplier.html new file mode 100644 index 0000000000..71bcd0262e --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/BooleanSupplier.html @@ -0,0 +1,234 @@ + + + + + +BooleanSupplier (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface BooleanSupplier

+
+
+
+
    +
  • +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface BooleanSupplier
    +
    A functional interface (callback) that returns a boolean value.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        getAsBoolean

        +
        boolean getAsBoolean()
+              throws Throwable
        +
        Returns a boolean value.
        +
        +
        Returns:
        +
        a boolean value
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Cancellable.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Cancellable.html new file mode 100644 index 0000000000..df9b37dd40 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Cancellable.html @@ -0,0 +1,233 @@ + + + + + +Cancellable (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface Cancellable

+
+
+
+
    +
  • +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface Cancellable
    +
    A functional interface that has a single cancel method + that can throw.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        cancel

        +
        void cancel()
+     throws Throwable
        +
        Cancel the action or free a resource.
        +
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Consumer.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Consumer.html new file mode 100644 index 0000000000..ac67de2c79 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Consumer.html @@ -0,0 +1,240 @@ + + + + + +Consumer (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface Consumer<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface Consumer<T>
    +
    A functional interface (callback) that accepts a single value.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        accept

        +
        void accept(T t)
+     throws Throwable
        +
        Consume the given value.
        +
        +
        Parameters:
        +
        t - the value
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function.html new file mode 100644 index 0000000000..55496e1af8 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function.html @@ -0,0 +1,244 @@ + + + + + +Function (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface Function<T,R>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the input value type
    +
    R - the output value type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface Function<T,R>
    +
    A functional interface that takes a value and returns another value, possibly with a + different type and allows throwing a checked exception.
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + +
      All Methods Instance Methods Abstract Methods 
      Modifier and TypeMethod and Description
      Rapply(T t) +
      Apply some calculation to the input value and return some other value.
      +
      +
      • +
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        apply

        +
        R apply(T t)
+ throws Throwable
        +
        Apply some calculation to the input value and return some other value.
        +
        +
        Parameters:
        +
        t - the input value
        +
        Returns:
        +
        the output value
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function3.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function3.html new file mode 100644 index 0000000000..59326d465c --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function3.html @@ -0,0 +1,251 @@ + + + + + +Function3 (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface Function3<T1,T2,T3,R>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T1 - the first value type
    +
    T2 - the second value type
    +
    T3 - the third value type
    +
    R - the result type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface Function3<T1,T2,T3,R>
    +
    A functional interface (callback) that computes a value based on multiple input values.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        apply

        +
        R apply(T1 t1,
+        T2 t2,
+        T3 t3)
+ throws Throwable
        +
        Calculate a value based on the input values.
        +
        +
        Parameters:
        +
        t1 - the first value
        +
        t2 - the second value
        +
        t3 - the third value
        +
        Returns:
        +
        the result value
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function4.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function4.html new file mode 100644 index 0000000000..a8634e053e --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function4.html @@ -0,0 +1,255 @@ + + + + + +Function4 (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface Function4<T1,T2,T3,T4,R>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T1 - the first value type
    +
    T2 - the second value type
    +
    T3 - the third value type
    +
    T4 - the fourth value type
    +
    R - the result type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface Function4<T1,T2,T3,T4,R>
    +
    A functional interface (callback) that computes a value based on multiple input values.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        apply

        +
        R apply(T1 t1,
+        T2 t2,
+        T3 t3,
+        T4 t4)
+ throws Throwable
        +
        Calculate a value based on the input values.
        +
        +
        Parameters:
        +
        t1 - the first value
        +
        t2 - the second value
        +
        t3 - the third value
        +
        t4 - the fourth value
        +
        Returns:
        +
        the result value
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function5.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function5.html new file mode 100644 index 0000000000..fde8891495 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function5.html @@ -0,0 +1,259 @@ + + + + + +Function5 (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface Function5<T1,T2,T3,T4,T5,R>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T1 - the first value type
    +
    T2 - the second value type
    +
    T3 - the third value type
    +
    T4 - the fourth value type
    +
    T5 - the fifth value type
    +
    R - the result type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface Function5<T1,T2,T3,T4,T5,R>
    +
    A functional interface (callback) that computes a value based on multiple input values.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        apply

        +
        R apply(T1 t1,
+        T2 t2,
+        T3 t3,
+        T4 t4,
+        T5 t5)
+ throws Throwable
        +
        Calculate a value based on the input values.
        +
        +
        Parameters:
        +
        t1 - the first value
        +
        t2 - the second value
        +
        t3 - the third value
        +
        t4 - the fourth value
        +
        t5 - the fifth value
        +
        Returns:
        +
        the result value
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function6.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function6.html new file mode 100644 index 0000000000..024e2cb4b1 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function6.html @@ -0,0 +1,263 @@ + + + + + +Function6 (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface Function6<T1,T2,T3,T4,T5,T6,R>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T1 - the first value type
    +
    T2 - the second value type
    +
    T3 - the third value type
    +
    T4 - the fourth value type
    +
    T5 - the fifth value type
    +
    T6 - the sixth value type
    +
    R - the result type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface Function6<T1,T2,T3,T4,T5,T6,R>
    +
    A functional interface (callback) that computes a value based on multiple input values.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        apply

        +
        R apply(T1 t1,
+        T2 t2,
+        T3 t3,
+        T4 t4,
+        T5 t5,
+        T6 t6)
+ throws Throwable
        +
        Calculate a value based on the input values.
        +
        +
        Parameters:
        +
        t1 - the first value
        +
        t2 - the second value
        +
        t3 - the third value
        +
        t4 - the fourth value
        +
        t5 - the fifth value
        +
        t6 - the sixth value
        +
        Returns:
        +
        the result value
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function7.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function7.html new file mode 100644 index 0000000000..64c111bf12 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function7.html @@ -0,0 +1,267 @@ + + + + + +Function7 (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface Function7<T1,T2,T3,T4,T5,T6,T7,R>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T1 - the first value type
    +
    T2 - the second value type
    +
    T3 - the third value type
    +
    T4 - the fourth value type
    +
    T5 - the fifth value type
    +
    T6 - the sixth value type
    +
    T7 - the seventh value type
    +
    R - the result type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface Function7<T1,T2,T3,T4,T5,T6,T7,R>
    +
    A functional interface (callback) that computes a value based on multiple input values.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        apply

        +
        R apply(T1 t1,
+        T2 t2,
+        T3 t3,
+        T4 t4,
+        T5 t5,
+        T6 t6,
+        T7 t7)
+ throws Throwable
        +
        Calculate a value based on the input values.
        +
        +
        Parameters:
        +
        t1 - the first value
        +
        t2 - the second value
        +
        t3 - the third value
        +
        t4 - the fourth value
        +
        t5 - the fifth value
        +
        t6 - the sixth value
        +
        t7 - the seventh value
        +
        Returns:
        +
        the result value
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function8.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function8.html new file mode 100644 index 0000000000..0d11c1997c --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function8.html @@ -0,0 +1,271 @@ + + + + + +Function8 (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface Function8<T1,T2,T3,T4,T5,T6,T7,T8,R>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T1 - the first value type
    +
    T2 - the second value type
    +
    T3 - the third value type
    +
    T4 - the fourth value type
    +
    T5 - the fifth value type
    +
    T6 - the sixth value type
    +
    T7 - the seventh value type
    +
    T8 - the eighth value type
    +
    R - the result type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface Function8<T1,T2,T3,T4,T5,T6,T7,T8,R>
    +
    A functional interface (callback) that computes a value based on multiple input values.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        apply

        +
        R apply(T1 t1,
+        T2 t2,
+        T3 t3,
+        T4 t4,
+        T5 t5,
+        T6 t6,
+        T7 t7,
+        T8 t8)
+ throws Throwable
        +
        Calculate a value based on the input values.
        +
        +
        Parameters:
        +
        t1 - the first value
        +
        t2 - the second value
        +
        t3 - the third value
        +
        t4 - the fourth value
        +
        t5 - the fifth value
        +
        t6 - the sixth value
        +
        t7 - the seventh value
        +
        t8 - the eighth value
        +
        Returns:
        +
        the result value
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function9.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function9.html new file mode 100644 index 0000000000..d65f6ea794 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Function9.html @@ -0,0 +1,275 @@ + + + + + +Function9 (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface Function9<T1,T2,T3,T4,T5,T6,T7,T8,T9,R>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T1 - the first value type
    +
    T2 - the second value type
    +
    T3 - the third value type
    +
    T4 - the fourth value type
    +
    T5 - the fifth value type
    +
    T6 - the sixth value type
    +
    T7 - the seventh value type
    +
    T8 - the eighth value type
    +
    T9 - the ninth value type
    +
    R - the result type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface Function9<T1,T2,T3,T4,T5,T6,T7,T8,T9,R>
    +
    A functional interface (callback) that computes a value based on multiple input values.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        apply

        +
        R apply(T1 t1,
+        T2 t2,
+        T3 t3,
+        T4 t4,
+        T5 t5,
+        T6 t6,
+        T7 t7,
+        T8 t8,
+        T9 t9)
+ throws Throwable
        +
        Calculate a value based on the input values.
        +
        +
        Parameters:
        +
        t1 - the first value
        +
        t2 - the second value
        +
        t3 - the third value
        +
        t4 - the fourth value
        +
        t5 - the fifth value
        +
        t6 - the sixth value
        +
        t7 - the seventh value
        +
        t8 - the eighth value
        +
        t9 - the ninth value
        +
        Returns:
        +
        the result value
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/IntFunction.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/IntFunction.html new file mode 100644 index 0000000000..9f5a36f413 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/IntFunction.html @@ -0,0 +1,240 @@ + + + + + +IntFunction (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface IntFunction<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the returned value type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface IntFunction<T>
    +
    A functional interface (callback) that takes a primitive value and return value of type T.
    +
    • +
+
+
+
    +
  • + + +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        apply

        +
        T apply(int i)
+ throws Throwable
        +
        Calculates a value based on a primitive integer input.
        +
        +
        Parameters:
        +
        i - the input value
        +
        Returns:
        +
        the result Object
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/LongConsumer.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/LongConsumer.html new file mode 100644 index 0000000000..2e6264b149 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/LongConsumer.html @@ -0,0 +1,234 @@ + + + + + +LongConsumer (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface LongConsumer

+
+
+
+
    +
  • +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface LongConsumer
    +
    A functional interface (callback) that consumes a primitive long value.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        accept

        +
        void accept(long t)
+     throws Throwable
        +
        Consume a primitive long input.
        +
        +
        Parameters:
        +
        t - the primitive long value
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Predicate.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Predicate.html new file mode 100644 index 0000000000..2f00b2fb43 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Predicate.html @@ -0,0 +1,242 @@ + + + + + +Predicate (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface Predicate<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the first value
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface Predicate<T>
    +
    A functional interface (callback) that returns true or false for the given input value.
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + +
      All Methods Instance Methods Abstract Methods 
      Modifier and TypeMethod and Description
      booleantest(T t) +
      Test the given input value and return a boolean.
      +
      +
      • +
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        test

        +
        boolean test(T t)
+      throws Throwable
        +
        Test the given input value and return a boolean.
        +
        +
        Parameters:
        +
        t - the value
        +
        Returns:
        +
        the boolean result
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Supplier.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Supplier.html new file mode 100644 index 0000000000..2c823fc98c --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/Supplier.html @@ -0,0 +1,250 @@ + + + + + +Supplier (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.functions
+

Interface Supplier<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type returned
    +
    +
    +
    All Known Subinterfaces:
    +
    ScalarSupplier<T>
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface Supplier<T>
    +
    A functional interface (callback) that provides a single value or + throws an exception. +

    + This interface was added to allow throwing any subclass of Throwables, + which is not directly possible with the Java standard Callable interface.

    +
    +
    Since:
    +
    3.0.0
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        get

        +
        T get()
+throws Throwable
        +
        Produces a value or throws an exception.
        +
        +
        Returns:
        +
        the value produced
        +
        Throws:
        +
        Throwable - if the implementation wishes to throw any type of exception
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/package-frame.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/package-frame.html new file mode 100644 index 0000000000..643de6d194 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/package-frame.html @@ -0,0 +1,37 @@ + + + + + +io.reactivex.rxjava3.functions (RxJava Javadoc 3.1.8) + + + + +

io.reactivex.rxjava3.functions

+
+

Interfaces

+ +
+ + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/package-summary.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/package-summary.html new file mode 100644 index 0000000000..3b8b786fab --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/package-summary.html @@ -0,0 +1,263 @@ + + + + + +io.reactivex.rxjava3.functions (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Package io.reactivex.rxjava3.functions

+
+
Functional interfaces of functions and actions of arity 0 to 9 and related + utility classes.
+
+

See: Description

+
+
+ + + + +

Package io.reactivex.rxjava3.functions Description

+
Functional interfaces of functions and actions of arity 0 to 9 and related + utility classes.
+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/package-tree.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/package-tree.html new file mode 100644 index 0000000000..14a031221e --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/functions/package-tree.html @@ -0,0 +1,148 @@ + + + + + +io.reactivex.rxjava3.functions Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For Package io.reactivex.rxjava3.functions

+Package Hierarchies: + +
+
+

Interface Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/ConnectableObservable.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/ConnectableObservable.html new file mode 100644 index 0000000000..006428720b --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/ConnectableObservable.html @@ -0,0 +1,781 @@ + + + + + +ConnectableObservable (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.observables
+

Class ConnectableObservable<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the type of items emitted by the ConnectableObservable
    +
    +
    +
    All Implemented Interfaces:
    +
    ObservableSource<T>
    +
    +
    +
    +
    public abstract class ConnectableObservable<T>
+extends Observable<T>
    +
    A ConnectableObservable resembles an ordinary Observable, except that it does not begin + emitting items when it is subscribed to, but only when its connect(io.reactivex.rxjava3.functions.Consumer<? super io.reactivex.rxjava3.disposables.Disposable>) method is called. In this way you + can wait for all intended Observers to Observable.subscribe() to the Observable + before the Observable begins emitting items. +

    + +

    + When the upstream terminates, the ConnectableObservable remains in this terminated state and, + depending on the actual underlying implementation, relays cached events to late Observers. + In order to reuse and restart this ConnectableObservable, the reset() method has to be called. + When called, this ConnectableObservable will appear as fresh, unconnected source to new Observers. + Disposing the connection will reset the ConnectableObservable to its fresh state and there is no need to call + reset() in this case. +

    + Note that although connect() and reset() are safe to call from multiple threads, it is recommended + a dedicated thread or business logic manages the connection or resetting of a ConnectableObservable so that + there is no unwanted signal loss due to early connect() or reset() calls while Observers are + still being subscribed to to this ConnectableObservable to receive signals from the get go.

    +
    +
    See Also:
    +
    RxJava Wiki: Connectable Observable Operators
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ConnectableObservable

        +
        public ConnectableObservable()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        connect

        +
        @SchedulerSupport(value="none")
+public abstract void connect(@NonNull Consumer<? super Disposable> connection)
        +
        Instructs the ConnectableObservable to begin emitting the items from its underlying + Observable to its Observers. +
        +
        Scheduler:
        +
        The behavior is determined by the implementor of this abstract class.
        +
        +
        +
        Parameters:
        +
        connection - the action that receives the connection subscription before the subscription to source happens + allowing the caller to synchronously disconnect a synchronous source
        +
        Throws:
        +
        NullPointerException - if connection is null
        +
        See Also:
        +
        ReactiveX documentation: Connect
        +
        +
        • +
      + + + +
        +
      • +

        reset

        +
        @SchedulerSupport(value="none")
+public abstract void reset()
        +
        Resets this ConnectableObservable into its fresh state if it has terminated + or has been disposed. +

        + Calling this method on a fresh or active ConnectableObservable has no effect. +

        +
        Scheduler:
        +
        The behavior is determined by the implementor of this abstract class.
        +
        +
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        refCount

        +
        @CheckReturnValue
+ @SchedulerSupport(value="none")
+ @NonNull
+public final @NonNull Observable<T> refCount(int observerCount)
        +
        Connects to the upstream ConnectableObservable if the number of subscribed + observers reaches the specified count and disconnect if all Observers have unsubscribed. +
        +
        Scheduler:
        +
        This refCount overload does not operate on any particular Scheduler.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        observerCount - the number of Observers required to connect to the upstream
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        IllegalArgumentException - if observerCount is non-positive
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + + + + + +
        +
      • +

        refCount

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> refCount(long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Connects to the upstream ConnectableObservable if the number of subscribed + observers reaches 1 and disconnect after the specified + timeout if all Observers have unsubscribed. +
        +
        Scheduler:
        +
        This refCount overload operates on the specified Scheduler.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        timeout - the time to wait before disconnecting after all Observers unsubscribed
        +
        unit - the time unit of the timeout
        +
        scheduler - the target scheduler to wait on before disconnecting
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + + + + + +
        +
      • +

        refCount

        +
        @CheckReturnValue
+ @SchedulerSupport(value="custom")
+ @NonNull
+public final @NonNull Observable<T> refCount(int observerCount,
+        long timeout,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Connects to the upstream ConnectableObservable if the number of subscribed + observers reaches the specified count and disconnect after the specified + timeout if all Observers have unsubscribed. +
        +
        Scheduler:
        +
        This refCount overload operates on the specified Scheduler.
        +
        +

        History: 2.1.14 - experimental

        +
        +
        Parameters:
        +
        observerCount - the number of Observers required to connect to the upstream
        +
        timeout - the time to wait before disconnecting after all Observers unsubscribed
        +
        unit - the time unit of the timeout
        +
        scheduler - the target scheduler to wait on before disconnecting
        +
        Returns:
        +
        the new Observable instance
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if observerCount is non-positive
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        autoConnect

        +
        @NonNull
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+public @NonNull Observable<T> autoConnect()
        +
        Returns an Observable that automatically connects (at most once) to this ConnectableObservable + when the first Observer subscribes. +

        + +

        + The connection happens after the first subscription and happens at most once + during the lifetime of the returned Observable. If this ConnectableObservable + terminates, the connection is never renewed, no matter how Observers come + and go. Use refCount() to renew a connection or dispose an active + connection when all Observers have disposed their Disposables. +

        + This overload does not allow disconnecting the connection established via + connect(Consumer). Use the autoConnect(int, Consumer) overload + to gain access to the Disposable representing the only connection. +

        +
        Scheduler:
        +
        autoConnect overload does not operate on any particular Scheduler.
        +
        +
        +
        Returns:
        +
        a new Observable instance that automatically connects to this ConnectableObservable + when the first Observer subscribes
        +
        +
        • +
      + + + +
        +
      • +

        autoConnect

        +
        @NonNull
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+public @NonNull Observable<T> autoConnect(int numberOfObservers)
        +
        Returns an Observable that automatically connects (at most once) to this ConnectableObservable + when the specified number of Observers subscribe to it. +

        + +

        + The connection happens after the given number of subscriptions and happens at most once + during the lifetime of the returned Observable. If this ConnectableObservable + terminates, the connection is never renewed, no matter how Observers come + and go. Use refCount() to renew a connection or dispose an active + connection when all Observers have disposed their Disposables. +

        + This overload does not allow disconnecting the connection established via + connect(Consumer). Use the autoConnect(int, Consumer) overload + to gain access to the Disposable representing the only connection. +

        +
        Scheduler:
        +
        autoConnect overload does not operate on any particular Scheduler.
        +
        +
        +
        Parameters:
        +
        numberOfObservers - the number of subscribers to await before calling connect + on the ConnectableObservable. A non-positive value indicates + an immediate connection.
        +
        Returns:
        +
        a new Observable instance that automatically connects to this ConnectableObservable + when the specified number of Observers subscribe to it
        +
        +
        • +
      + + + +
        +
      • +

        autoConnect

        +
        @NonNull
+ @CheckReturnValue
+ @SchedulerSupport(value="none")
+public @NonNull Observable<T> autoConnect(int numberOfObservers,
+        @NonNull Consumer<? super Disposable> connection)
        +
        Returns an Observable that automatically connects (at most once) to this ConnectableObservable + when the specified number of Observers subscribe to it and calls the + specified callback with the Disposable associated with the established connection. +

        + +

        + The connection happens after the given number of subscriptions and happens at most once + during the lifetime of the returned Observable. If this ConnectableObservable + terminates, the connection is never renewed, no matter how Observers come + and go. Use refCount() to renew a connection or dispose an active + connection when all Observers have disposed their Disposables. +

        +
        Scheduler:
        +
        autoConnect overload does not operate on any particular Scheduler.
        +
        +
        +
        Parameters:
        +
        numberOfObservers - the number of subscribers to await before calling connect + on the ConnectableObservable. A non-positive value indicates + an immediate connection.
        +
        connection - the callback Consumer that will receive the Disposable representing the + established connection
        +
        Returns:
        +
        a new Observable instance that automatically connects to this ConnectableObservable + when the specified number of Observers subscribe to it and calls the + specified callback with the Disposable associated with the established connection
        +
        Throws:
        +
        NullPointerException - if connection is null
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/GroupedObservable.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/GroupedObservable.html new file mode 100644 index 0000000000..95ace4e985 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/GroupedObservable.html @@ -0,0 +1,320 @@ + + + + + +GroupedObservable (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.observables
+

Class GroupedObservable<K,T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    K - the type of the key
    +
    T - the type of the items emitted by the GroupedObservable
    +
    +
    +
    All Implemented Interfaces:
    +
    ObservableSource<T>
    +
    +
    +
    +
    public abstract class GroupedObservable<K,T>
+extends Observable<T>
    +
    An Observable that has been grouped by key, the value of which can be obtained with getKey(). +

    + Note: A GroupedObservable will cache the items it is to emit until such time as it + is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those + GroupedObservables that do not concern you. Instead, you can signal to them that they + may discard their buffers by applying an operator like take(0) to them.

    +
    +
    See Also:
    +
    Observable.groupBy(io.reactivex.rxjava3.functions.Function), +ReactiveX documentation: GroupBy
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        GroupedObservable

        +
        protected GroupedObservable(@Nullable
+                            K key)
        +
        Constructs a GroupedObservable with the given key.
        +
        +
        Parameters:
        +
        key - the key
        +
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        getKey

        +
        @Nullable
+public K getKey()
        +
        Returns the key that identifies the group of items emitted by this GroupedObservable.
        +
        +
        Returns:
        +
        the key that the items emitted by this GroupedObservable were grouped by
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/package-frame.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/package-frame.html new file mode 100644 index 0000000000..1dc5c1fa38 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/package-frame.html @@ -0,0 +1,20 @@ + + + + + +io.reactivex.rxjava3.observables (RxJava Javadoc 3.1.8) + + + + +

io.reactivex.rxjava3.observables

+
+

Classes

+ +
+ + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/package-summary.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/package-summary.html new file mode 100644 index 0000000000..f0ca485fbb --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/package-summary.html @@ -0,0 +1,161 @@ + + + + + +io.reactivex.rxjava3.observables (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Package io.reactivex.rxjava3.observables

+
+
Classes supporting the Observable base reactive class: + ConnectableObservable and + GroupedObservable.
+
+

See: Description

+
+
+ + + + +

Package io.reactivex.rxjava3.observables Description

+
Classes supporting the Observable base reactive class: + ConnectableObservable and + GroupedObservable.
+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/package-tree.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/package-tree.html new file mode 100644 index 0000000000..5b0adfaa1d --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observables/package-tree.html @@ -0,0 +1,139 @@ + + + + + +io.reactivex.rxjava3.observables Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For Package io.reactivex.rxjava3.observables

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/BaseTestConsumer.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/BaseTestConsumer.html new file mode 100644 index 0000000000..9069896c60 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/BaseTestConsumer.html @@ -0,0 +1,1175 @@ + + + + + +BaseTestConsumer (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + +
+
io.reactivex.rxjava3.observers
+

Class BaseTestConsumer<T,U extends BaseTestConsumer<T,U>>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type consumed
    +
    U - the subclass of this BaseTestConsumer
    +
    +
    +
    Direct Known Subclasses:
    +
    TestObserver, TestSubscriber
    +
    +
    +
    +
    public abstract class BaseTestConsumer<T,U extends BaseTestConsumer<T,U>>
+extends Object
    +
    Base class with shared infrastructure to support + TestSubscriber and TestObserver.
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      Fields 
      Modifier and TypeField and Description
      protected booleancheckSubscriptionOnce 
      protected longcompletions +
      The number of completions.
      +
      protected CountDownLatchdone +
      The latch that indicates an onError or onComplete has been called.
      +
      protected List<Throwable>errors +
      The list of errors received.
      +
      protected ThreadlastThread +
      The last thread seen by the observer.
      +
      protected CharSequencetag +
      The optional tag associated with this test consumer.
      +
      protected booleantimeout +
      Indicates that one of the awaitX method has timed out.
      +
      protected List<T>values +
      The list of values received.
      +
      +
      • +
    + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      BaseTestConsumer() +
      Constructs a BaseTestConsumer with CountDownLatch set to 1.
      +
      +
      • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and TypeMethod and Description
      UassertComplete() +
      Assert that this TestObserver/TestSubscriber received exactly one onComplete event.
      +
      UassertEmpty() +
      Assert that the TestObserver/TestSubscriber has received a + Disposable/Subscription + via onSubscribe but no other events.
      +
      UassertError(@NonNull Class<? extends Throwable> errorClass) +
      Asserts that this TestObserver/TestSubscriber received exactly one onError event which is an + instance of the specified errorClass Class.
      +
      UassertError(@NonNull Predicate<Throwable> errorPredicate) +
      Asserts that this TestObserver/TestSubscriber received exactly one onError event for which + the provided predicate returns true.
      +
      UassertError(@NonNull Throwable error) +
      Assert that this TestObserver/TestSubscriber received exactly the specified onError event value.
      +
      UassertFailure(@NonNull Class<? extends Throwable> error, + T... values) +
      Assert that the upstream signaled the specified values in order + and then failed with a specific class or subclass of Throwable.
      +
      UassertNoErrors() +
      Assert that this TestObserver/TestSubscriber has not received an onError event.
      +
      UassertNotComplete() +
      Assert that this TestObserver/TestSubscriber has not received an onComplete event.
      +
      UassertNoValues() +
      Assert that this TestObserver/TestSubscriber has not received any onNext events.
      +
      UassertResult(T... values) +
      Assert that the upstream signaled the specified values in order and + completed normally.
      +
      protected abstract UassertSubscribed() +
      Assert that the onSubscribe method was called exactly once.
      +
      UassertValue(@NonNull Predicate<T> valuePredicate) +
      Asserts that this TestObserver/TestSubscriber received exactly one onNext value for which + the provided predicate returns true.
      +
      UassertValue(T value) +
      Assert that this TestObserver/TestSubscriber received exactly one onNext value which is equal to + the given value with respect to Objects.equals(Object, Object).
      +
      UassertValueAt(int index, + @NonNull Predicate<T> valuePredicate) +
      Asserts that this TestObserver/TestSubscriber received an onNext value at the given index + for the provided predicate returns true.
      +
      UassertValueAt(int index, + T value) +
      Asserts that this TestObserver/TestSubscriber received an onNext value at the given index + which is equal to the given value with respect to null-safe Objects.equals(Object, Object).
      +
      UassertValueCount(int count) +
      Assert that this TestObserver/TestSubscriber received the specified number onNext events.
      +
      UassertValues(T... values) +
      Assert that the TestObserver/TestSubscriber received only the specified values in the specified order.
      +
      UassertValueSequence(@NonNull Iterable<? extends T> sequence) +
      Assert that the TestObserver/TestSubscriber received only the specified sequence of values in the same order.
      +
      UassertValuesOnly(T... values) +
      Assert that the TestObserver/TestSubscriber received only the specified values in the specified order without terminating.
      +
      Uawait() +
      Awaits until this TestObserver/TestSubscriber receives an onError or onComplete events.
      +
      booleanawait(long time, + @NonNull TimeUnit unit) +
      Awaits the specified amount of time or until this TestObserver/TestSubscriber + receives an onError or onComplete events, whichever happens first.
      +
      UawaitCount(int atLeast) +
      Await until the TestObserver/TestSubscriber receives the given + number of items or terminates by sleeping 10 milliseconds at a time + up to 5000 milliseconds of timeout.
      +
      UawaitDone(long time, + @NonNull TimeUnit unit) +
      Awaits until the internal latch is counted down.
      +
      protected abstract voiddispose() +
      Cancel/dispose this test consumer.
      +
      protected @NonNull AssertionErrorfail(@NonNull String message) +
      Fail with the given message and add the sequence of errors as suppressed ones.
      +
      protected abstract booleanisDisposed() +
      Returns true if this test consumer was cancelled/disposed.
      +
      static @NonNull StringvalueAndClass(@Nullable Object o) +
      Appends the class name to a non-null value or returns "null".
      +
      @NonNull List<T>values() +
      Returns a shared list of received onNext values or the single onSuccess value.
      +
      UwithTag(@Nullable CharSequence tag) +
      Set the tag displayed along with an assertion failure's + other state information.
      +
      + +
      • +
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        done

        +
        protected final CountDownLatch done
        +
        The latch that indicates an onError or onComplete has been called.
        +
        • +
      + + + +
        +
      • +

        values

        +
        protected final List<T> values
        +
        The list of values received.
        +
        • +
      + + + +
        +
      • +

        errors

        +
        protected final List<Throwable> errors
        +
        The list of errors received.
        +
        • +
      + + + +
        +
      • +

        completions

        +
        protected long completions
        +
        The number of completions.
        +
        • +
      + + + +
        +
      • +

        lastThread

        +
        protected Thread lastThread
        +
        The last thread seen by the observer.
        +
        • +
      + + + +
        +
      • +

        checkSubscriptionOnce

        +
        protected boolean checkSubscriptionOnce
        +
        • +
      + + + +
        +
      • +

        tag

        +
        protected CharSequence tag
        +
        The optional tag associated with this test consumer.
        +
        +
        Since:
        +
        2.0.7
        +
        +
        • +
      + + + +
        +
      • +

        timeout

        +
        protected boolean timeout
        +
        Indicates that one of the awaitX method has timed out.
        +
        +
        Since:
        +
        2.0.7
        +
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        BaseTestConsumer

        +
        public BaseTestConsumer()
        +
        Constructs a BaseTestConsumer with CountDownLatch set to 1.
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        values

        +
        @NonNull
+public final @NonNull List<T> values()
        +
        Returns a shared list of received onNext values or the single onSuccess value. +

        + Note that accessing the items via certain methods of the List + interface while the upstream is still actively emitting + more items may result in a ConcurrentModificationException. +

        + The List.size() method will return the number of items + already received by this TestObserver/TestSubscriber in a thread-safe + manner that can be read via List.get(int)) method + (index range of 0 to List.size() - 1). +

        + A view of the returned List can be created via List.subList(int, int) + by using the bounds 0 (inclusive) to List.size() (exclusive) which, + when accessed in a read-only fashion, should be also thread-safe and not throw any + ConcurrentModificationException.

        +
        +
        Returns:
        +
        a list of received onNext values
        +
        +
        • +
      + + + +
        +
      • +

        fail

        +
        @NonNull
+protected final @NonNull AssertionError fail(@NonNull String message)
        +
        Fail with the given message and add the sequence of errors as suppressed ones. +

        Note this is deliberately the only fail method. Most of the times an assertion + would fail but it is possible it was due to an exception somewhere. This construct + will capture those potential errors and report it along with the original failure.

        +
        +
        Parameters:
        +
        message - the message to use
        +
        Returns:
        +
        AssertionError the prepared AssertionError instance
        +
        +
        • +
      + + + +
        +
      • +

        await

        +
        @NonNull
+public final U await()
+                       throws InterruptedException
        +
        Awaits until this TestObserver/TestSubscriber receives an onError or onComplete events.
        +
        +
        Returns:
        +
        this
        +
        Throws:
        +
        InterruptedException - if the current thread is interrupted while waiting
        +
        +
        • +
      + + + +
        +
      • +

        await

        +
        public final boolean await(long time,
+        @NonNull TimeUnit unit)
+                    throws InterruptedException
        +
        Awaits the specified amount of time or until this TestObserver/TestSubscriber + receives an onError or onComplete events, whichever happens first.
        +
        +
        Parameters:
        +
        time - the waiting time
        +
        unit - the time unit of the waiting time
        +
        Returns:
        +
        true if the TestObserver/TestSubscriber terminated, false if timeout happened
        +
        Throws:
        +
        InterruptedException - if the current thread is interrupted while waiting
        +
        +
        • +
      + + + +
        +
      • +

        assertComplete

        +
        @NonNull
+public final U assertComplete()
        +
        Assert that this TestObserver/TestSubscriber received exactly one onComplete event.
        +
        +
        Returns:
        +
        this
        +
        +
        • +
      + + + +
        +
      • +

        assertNotComplete

        +
        @NonNull
+public final U assertNotComplete()
        +
        Assert that this TestObserver/TestSubscriber has not received an onComplete event.
        +
        +
        Returns:
        +
        this
        +
        +
        • +
      + + + +
        +
      • +

        assertNoErrors

        +
        @NonNull
+public final U assertNoErrors()
        +
        Assert that this TestObserver/TestSubscriber has not received an onError event.
        +
        +
        Returns:
        +
        this
        +
        +
        • +
      + + + + + + + +
        +
      • +

        assertError

        +
        @NonNull
+public final U assertError(@NonNull Class<? extends Throwable> errorClass)
        +
        Asserts that this TestObserver/TestSubscriber received exactly one onError event which is an + instance of the specified errorClass Class.
        +
        +
        Parameters:
        +
        errorClass - the error Class to expect
        +
        Returns:
        +
        this
        +
        +
        • +
      + + + +
        +
      • +

        assertError

        +
        @NonNull
+public final U assertError(@NonNull Predicate<Throwable> errorPredicate)
        +
        Asserts that this TestObserver/TestSubscriber received exactly one onError event for which + the provided predicate returns true.
        +
        +
        Parameters:
        +
        errorPredicate - the predicate that receives the error Throwable + and should return true for expected errors.
        +
        Returns:
        +
        this
        +
        +
        • +
      + + + + + +
        +
      • +

        assertValue

        +
        @NonNull
+public final U assertValue(@NonNull T value)
        +
        Assert that this TestObserver/TestSubscriber received exactly one onNext value which is equal to + the given value with respect to Objects.equals(Object, Object).
        +
        +
        Parameters:
        +
        value - the value to expect
        +
        Returns:
        +
        this
        +
        +
        • +
      + + + +
        +
      • +

        assertValue

        +
        @NonNull
+public final U assertValue(@NonNull Predicate<T> valuePredicate)
        +
        Asserts that this TestObserver/TestSubscriber received exactly one onNext value for which + the provided predicate returns true.
        +
        +
        Parameters:
        +
        valuePredicate - the predicate that receives the onNext value + and should return true for the expected value.
        +
        Returns:
        +
        this
        +
        +
        • +
      + + + + + +
        +
      • +

        assertValueAt

        +
        @NonNull
+public final U assertValueAt(int index,
+        @NonNull T value)
        +
        Asserts that this TestObserver/TestSubscriber received an onNext value at the given index + which is equal to the given value with respect to null-safe Objects.equals(Object, Object). +

        History: 2.1.3 - experimental

        +
        +
        Parameters:
        +
        index - the position to assert on
        +
        value - the value to expect
        +
        Returns:
        +
        this
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        assertValueAt

        +
        @NonNull
+public final U assertValueAt(int index,
+        @NonNull Predicate<T> valuePredicate)
        +
        Asserts that this TestObserver/TestSubscriber received an onNext value at the given index + for the provided predicate returns true.
        +
        +
        Parameters:
        +
        index - the position to assert on
        +
        valuePredicate - the predicate that receives the onNext value + and should return true for the expected value.
        +
        Returns:
        +
        this
        +
        +
        • +
      + + + +
        +
      • +

        valueAndClass

        +
        @NonNull
+public static @NonNull String valueAndClass(@Nullable Object o)
        +
        Appends the class name to a non-null value or returns "null".
        +
        +
        Parameters:
        +
        o - the object
        +
        Returns:
        +
        the string representation
        +
        +
        • +
      + + + +
        +
      • +

        assertValueCount

        +
        @NonNull
+public final U assertValueCount(int count)
        +
        Assert that this TestObserver/TestSubscriber received the specified number onNext events.
        +
        +
        Parameters:
        +
        count - the expected number of onNext events
        +
        Returns:
        +
        this
        +
        +
        • +
      + + + +
        +
      • +

        assertNoValues

        +
        @NonNull
+public final U assertNoValues()
        +
        Assert that this TestObserver/TestSubscriber has not received any onNext events.
        +
        +
        Returns:
        +
        this
        +
        +
        • +
      + + + + + +
        +
      • +

        assertValues

        +
        @SafeVarargs
+ @NonNull
+public final U assertValues(@NonNull T... values)
        +
        Assert that the TestObserver/TestSubscriber received only the specified values in the specified order.
        +
        +
        Parameters:
        +
        values - the values expected
        +
        Returns:
        +
        this
        +
        +
        • +
      + + + + + +
        +
      • +

        assertValuesOnly

        +
        @SafeVarargs
+ @NonNull
+public final U assertValuesOnly(@NonNull T... values)
        +
        Assert that the TestObserver/TestSubscriber received only the specified values in the specified order without terminating. +

        History: 2.1.4 - experimental

        +
        +
        Parameters:
        +
        values - the values expected
        +
        Returns:
        +
        this
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        assertValueSequence

        +
        @NonNull
+public final U assertValueSequence(@NonNull Iterable<? extends T> sequence)
        +
        Assert that the TestObserver/TestSubscriber received only the specified sequence of values in the same order.
        +
        +
        Parameters:
        +
        sequence - the sequence of expected values in order
        +
        Returns:
        +
        this
        +
        +
        • +
      + + + +
        +
      • +

        assertSubscribed

        +
        @NonNull
+protected abstract U assertSubscribed()
        +
        Assert that the onSubscribe method was called exactly once.
        +
        +
        Returns:
        +
        this
        +
        +
        • +
      + + + + + +
        +
      • +

        assertResult

        +
        @SafeVarargs
+ @NonNull
+public final U assertResult(@NonNull T... values)
        +
        Assert that the upstream signaled the specified values in order and + completed normally.
        +
        +
        Parameters:
        +
        values - the expected values, asserted in order
        +
        Returns:
        +
        this
        +
        See Also:
        +
        assertFailure(Class, Object...)
        +
        +
        • +
      + + + + + +
        +
      • +

        assertFailure

        +
        @SafeVarargs
+ @NonNull
+public final U assertFailure(@NonNull Class<? extends Throwable> error,
+        @NonNull T... values)
        +
        Assert that the upstream signaled the specified values in order + and then failed with a specific class or subclass of Throwable.
        +
        +
        Parameters:
        +
        error - the expected exception (parent) Class
        +
        values - the expected values, asserted in order
        +
        Returns:
        +
        this
        +
        +
        • +
      + + + +
        +
      • +

        awaitDone

        +
        @NonNull
+public final U awaitDone(long time,
+        @NonNull TimeUnit unit)
        +
        Awaits until the internal latch is counted down. +

        If the wait times out or gets interrupted, the TestObserver/TestSubscriber is cancelled.

        +
        +
        Parameters:
        +
        time - the waiting time
        +
        unit - the time unit of the waiting time
        +
        Returns:
        +
        this
        +
        Throws:
        +
        RuntimeException - wrapping an InterruptedException if the wait is interrupted
        +
        +
        • +
      + + + +
        +
      • +

        assertEmpty

        +
        @NonNull
+public final U assertEmpty()
        +
        Assert that the TestObserver/TestSubscriber has received a + Disposable/Subscription + via onSubscribe but no other events.
        +
        +
        Returns:
        +
        this
        +
        +
        • +
      + + + +
        +
      • +

        withTag

        +
        @NonNull
+public final U withTag(@Nullable CharSequence tag)
        +
        Set the tag displayed along with an assertion failure's + other state information. +

        History: 2.0.7 - experimental

        +
        +
        Parameters:
        +
        tag - the string to display (null won't print any tag)
        +
        Returns:
        +
        this
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + +
        +
      • +

        awaitCount

        +
        @NonNull
+public final U awaitCount(int atLeast)
        +
        Await until the TestObserver/TestSubscriber receives the given + number of items or terminates by sleeping 10 milliseconds at a time + up to 5000 milliseconds of timeout. +

        History: 2.0.7 - experimental

        +
        +
        Parameters:
        +
        atLeast - the number of items expected at least
        +
        Returns:
        +
        this
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + +
        +
      • +

        isDisposed

        +
        protected abstract boolean isDisposed()
        +
        Returns true if this test consumer was cancelled/disposed.
        +
        +
        Returns:
        +
        true if this test consumer was cancelled/disposed.
        +
        +
        • +
      + + + +
        +
      • +

        dispose

        +
        protected abstract void dispose()
        +
        Cancel/dispose this test consumer.
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DefaultObserver.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DefaultObserver.html new file mode 100644 index 0000000000..55580478c2 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DefaultObserver.html @@ -0,0 +1,372 @@ + + + + + +DefaultObserver (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.observers
+

Class DefaultObserver<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    All Implemented Interfaces:
    +
    Observer<T>
    +
    +
    +
    +
    public abstract class DefaultObserver<T>
+extends Object
+implements Observer<T>
    +
    Abstract base implementation of an Observer with support for cancelling a + subscription via cancel() (synchronously) and calls onStart() + when the subscription happens. + +

    All pre-implemented final methods are thread-safe. + +

    Use the protected cancel() to dispose the sequence from within an + onNext implementation. + +

    Like all other consumers, DefaultObserver can be subscribed only once. + Any subsequent attempt to subscribe it to a new source will yield an + IllegalStateException with message "It is not allowed to subscribe with a(n) <class name> multiple times.". + +

    Implementation of onStart(), Observer.onNext(Object), Observer.onError(Throwable) + and Observer.onComplete() are not allowed to throw any unchecked exceptions. + If for some reason this can't be avoided, use Observable.safeSubscribe(io.reactivex.rxjava3.core.Observer) + instead of the standard subscribe() method. + +

    Example

    
+ Observable.range(1, 5)
+     .subscribe(new DefaultObserver<Integer>() {
+         @Override public void onStart() {
+             System.out.println("Start!");
+         }
+         @Override public void onNext(Integer t) {
+             if (t == 3) {
+                 cancel();
+             }
+             System.out.println(t);
+         }
+         @Override public void onError(Throwable t) {
+             t.printStackTrace();
+         }
+         @Override public void onComplete() {
+             System.out.println("Done!");
+         }
+     });
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        DefaultObserver

        +
        public DefaultObserver()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        cancel

        +
        protected final void cancel()
        +
        Cancels the upstream's disposable.
        +
        • +
      + + + +
        +
      • +

        onStart

        +
        protected void onStart()
        +
        Called once the subscription has been set on this observer; override this + to perform initialization.
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableCompletableObserver.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableCompletableObserver.html new file mode 100644 index 0000000000..696dbcb1e9 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableCompletableObserver.html @@ -0,0 +1,388 @@ + + + + + +DisposableCompletableObserver (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.observers
+

Class DisposableCompletableObserver

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    CompletableObserver, Disposable
    +
    +
    +
    +
    public abstract class DisposableCompletableObserver
+extends Object
+implements CompletableObserver, Disposable
    +
    An abstract CompletableObserver that allows asynchronous cancellation by implementing Disposable. + +

    All pre-implemented final methods are thread-safe. + +

    Like all other consumers, DisposableCompletableObserver can be subscribed only once. + Any subsequent attempt to subscribe it to a new source will yield an + IllegalStateException with message "It is not allowed to subscribe with a(n) <class name> multiple times.". + +

    Implementation of onStart(), CompletableObserver.onError(Throwable) and + CompletableObserver.onComplete() are not allowed to throw any unchecked exceptions. + +

    Example

    
+ Disposable d =
+     Completable.complete().delay(1, TimeUnit.SECONDS)
+     .subscribeWith(new DisposableMaybeObserver<Integer>() {
+         @Override public void onStart() {
+             System.out.println("Start!");
+         }
+         @Override public void onError(Throwable t) {
+             t.printStackTrace();
+         }
+         @Override public void onComplete() {
+             System.out.println("Done!");
+         }
+     });
+ // ...
+ d.dispose();
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        DisposableCompletableObserver

        +
        public DisposableCompletableObserver()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + + + + + +
        +
      • +

        isDisposed

        +
        public final boolean isDisposed()
        +
        Description copied from interface: Disposable
        +
        Returns true if this resource has been disposed.
        +
        +
        Specified by:
        +
        isDisposed in interface Disposable
        +
        Returns:
        +
        true if this resource has been disposed
        +
        +
        • +
      + + + +
        +
      • +

        dispose

        +
        public final void dispose()
        +
        Description copied from interface: Disposable
        +
        Dispose the resource, the operation should be idempotent.
        +
        +
        Specified by:
        +
        dispose in interface Disposable
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableMaybeObserver.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableMaybeObserver.html new file mode 100644 index 0000000000..54c301b662 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableMaybeObserver.html @@ -0,0 +1,402 @@ + + + + + +DisposableMaybeObserver (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.observers
+

Class DisposableMaybeObserver<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the received value type
    +
    +
    +
    All Implemented Interfaces:
    +
    MaybeObserver<T>, Disposable
    +
    +
    +
    +
    public abstract class DisposableMaybeObserver<T>
+extends Object
+implements MaybeObserver<T>, Disposable
    +
    An abstract MaybeObserver that allows asynchronous cancellation by implementing Disposable. + +

    All pre-implemented final methods are thread-safe. + +

    Note that MaybeObserver.onSuccess(Object), MaybeObserver.onError(Throwable) and MaybeObserver.onComplete() are + exclusive to each other, unlike a regular Observer, and + onComplete() is never called after an onSuccess(). + +

    Like all other consumers, DisposableMaybeObserver can be subscribed only once. + Any subsequent attempt to subscribe it to a new source will yield an + IllegalStateException with message "It is not allowed to subscribe with a(n) <class name> multiple times.". + +

    Implementation of onStart(), MaybeObserver.onSuccess(Object), MaybeObserver.onError(Throwable) and + MaybeObserver.onComplete() are not allowed to throw any unchecked exceptions. + +

    Example

    
+ Disposable d =
+     Maybe.just(1).delay(1, TimeUnit.SECONDS)
+     .subscribeWith(new DisposableMaybeObserver<Integer>() {
+         @Override public void onStart() {
+             System.out.println("Start!");
+         }
+         @Override public void onSuccess(Integer t) {
+             System.out.println(t);
+         }
+         @Override public void onError(Throwable t) {
+             t.printStackTrace();
+         }
+         @Override public void onComplete() {
+             System.out.println("Done!");
+         }
+     });
+ // ...
+ d.dispose();
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        DisposableMaybeObserver

        +
        public DisposableMaybeObserver()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + + + + + +
        +
      • +

        isDisposed

        +
        public final boolean isDisposed()
        +
        Description copied from interface: Disposable
        +
        Returns true if this resource has been disposed.
        +
        +
        Specified by:
        +
        isDisposed in interface Disposable
        +
        Returns:
        +
        true if this resource has been disposed
        +
        +
        • +
      + + + +
        +
      • +

        dispose

        +
        public final void dispose()
        +
        Description copied from interface: Disposable
        +
        Dispose the resource, the operation should be idempotent.
        +
        +
        Specified by:
        +
        dispose in interface Disposable
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableObserver.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableObserver.html new file mode 100644 index 0000000000..3391b03878 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableObserver.html @@ -0,0 +1,406 @@ + + + + + +DisposableObserver (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.observers
+

Class DisposableObserver<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the received value type
    +
    +
    +
    All Implemented Interfaces:
    +
    Observer<T>, Disposable
    +
    +
    +
    +
    public abstract class DisposableObserver<T>
+extends Object
+implements Observer<T>, Disposable
    +
    An abstract Observer that allows asynchronous cancellation by implementing Disposable. + +

    All pre-implemented final methods are thread-safe. + +

    Use the public dispose() method to dispose the sequence from within an + onNext implementation. + +

    Like all other consumers, DisposableObserver can be subscribed only once. + Any subsequent attempt to subscribe it to a new source will yield an + IllegalStateException with message "It is not allowed to subscribe with a(n) <class name> multiple times.". + +

    Implementation of onStart(), Observer.onNext(Object), Observer.onError(Throwable) + and Observer.onComplete() are not allowed to throw any unchecked exceptions. + If for some reason this can't be avoided, use Observable.safeSubscribe(io.reactivex.rxjava3.core.Observer) + instead of the standard subscribe() method. + +

    Example

    
+ Disposable d =
+     Observable.range(1, 5)
+     .subscribeWith(new DisposableObserver<Integer>() {
+         @Override public void onStart() {
+             System.out.println("Start!");
+         }
+         @Override public void onNext(Integer t) {
+             if (t == 3) {
+                 dispose();
+             }
+             System.out.println(t);
+         }
+         @Override public void onError(Throwable t) {
+             t.printStackTrace();
+         }
+         @Override public void onComplete() {
+             System.out.println("Done!");
+         }
+     });
+ // ...
+ d.dispose();
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        DisposableObserver

        +
        public DisposableObserver()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        onStart

        +
        protected void onStart()
        +
        Called once the single upstream Disposable is set via onSubscribe.
        +
        • +
      + + + +
        +
      • +

        isDisposed

        +
        public final boolean isDisposed()
        +
        Description copied from interface: Disposable
        +
        Returns true if this resource has been disposed.
        +
        +
        Specified by:
        +
        isDisposed in interface Disposable
        +
        Returns:
        +
        true if this resource has been disposed
        +
        +
        • +
      + + + +
        +
      • +

        dispose

        +
        public final void dispose()
        +
        Description copied from interface: Disposable
        +
        Dispose the resource, the operation should be idempotent.
        +
        +
        Specified by:
        +
        dispose in interface Disposable
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableSingleObserver.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableSingleObserver.html new file mode 100644 index 0000000000..ecc9e2b07d --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/DisposableSingleObserver.html @@ -0,0 +1,395 @@ + + + + + +DisposableSingleObserver (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.observers
+

Class DisposableSingleObserver<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the received value type
    +
    +
    +
    All Implemented Interfaces:
    +
    SingleObserver<T>, Disposable
    +
    +
    +
    +
    public abstract class DisposableSingleObserver<T>
+extends Object
+implements SingleObserver<T>, Disposable
    +
    An abstract SingleObserver that allows asynchronous cancellation by implementing Disposable. + +

    All pre-implemented final methods are thread-safe. + +

    Like all other consumers, DisposableSingleObserver can be subscribed only once. + Any subsequent attempt to subscribe it to a new source will yield an + IllegalStateException with message "It is not allowed to subscribe with a(n) <class name> multiple times.". + +

    Implementation of onStart(), SingleObserver.onSuccess(Object) and SingleObserver.onError(Throwable) + are not allowed to throw any unchecked exceptions. + +

    Example

    
+ Disposable d =
+     Single.just(1).delay(1, TimeUnit.SECONDS)
+     .subscribeWith(new DisposableSingleObserver<Integer>() {
+         @Override public void onStart() {
+             System.out.println("Start!");
+         }
+         @Override public void onSuccess(Integer t) {
+             System.out.println(t);
+         }
+         @Override public void onError(Throwable t) {
+             t.printStackTrace();
+         }
+     });
+ // ...
+ d.dispose();
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        DisposableSingleObserver

        +
        public DisposableSingleObserver()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        onSubscribe

        +
        public final void onSubscribe(@NonNull
+                              @NonNull Disposable d)
        +
        Description copied from interface: SingleObserver
        +
        Provides the SingleObserver with the means of cancelling (disposing) the + connection (channel) with the Single in both + synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.
        +
        +
        Specified by:
        +
        onSubscribe in interface SingleObserver<T>
        +
        Parameters:
        +
        d - the Disposable instance whose Disposable.dispose() can + be called anytime to cancel the connection
        +
        +
        • +
      + + + + + + + +
        +
      • +

        isDisposed

        +
        public final boolean isDisposed()
        +
        Description copied from interface: Disposable
        +
        Returns true if this resource has been disposed.
        +
        +
        Specified by:
        +
        isDisposed in interface Disposable
        +
        Returns:
        +
        true if this resource has been disposed
        +
        +
        • +
      + + + +
        +
      • +

        dispose

        +
        public final void dispose()
        +
        Description copied from interface: Disposable
        +
        Dispose the resource, the operation should be idempotent.
        +
        +
        Specified by:
        +
        dispose in interface Disposable
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/LambdaConsumerIntrospection.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/LambdaConsumerIntrospection.html new file mode 100644 index 0000000000..a47907d138 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/LambdaConsumerIntrospection.html @@ -0,0 +1,235 @@ + + + + + +LambdaConsumerIntrospection (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.observers
+

Interface LambdaConsumerIntrospection

+
+
+
+
    +
  • +
    +
    +
    public interface LambdaConsumerIntrospection
    +
    An interface that indicates that the implementing type is composed of individual components and exposes information + about their behavior. + +

    NOTE: This is considered a read-only public API and is not intended to be implemented externally. +

    History: 2.1.4 - experimental

    +
    +
    Since:
    +
    2.2
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        hasCustomOnError

        +
        boolean hasCustomOnError()
        +
        Returns true or false if a custom onError consumer has been provided.
        +
        +
        Returns:
        +
        true if a custom onError consumer implementation was supplied. Returns false if the + implementation is missing an error consumer and thus using a throwing default implementation.
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceCompletableObserver.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceCompletableObserver.html new file mode 100644 index 0000000000..c487b01c02 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceCompletableObserver.html @@ -0,0 +1,437 @@ + + + + + +ResourceCompletableObserver (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.observers
+

Class ResourceCompletableObserver

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    CompletableObserver, Disposable
    +
    +
    +
    +
    public abstract class ResourceCompletableObserver
+extends Object
+implements CompletableObserver, Disposable
    +
    An abstract CompletableObserver that allows asynchronous cancellation of its subscription and associated resources. + +

    All pre-implemented final methods are thread-safe. + +

    Override the protected onStart() to perform initialization when this + ResourceCompletableObserver is subscribed to a source. + +

    Use the public dispose() method to dispose the sequence externally and release + all resources. + +

    To release the associated resources, one has to call dispose() + in onError() and onComplete() explicitly. + +

    Use add(Disposable) to associate resources (as Disposables) + with this ResourceCompletableObserver that will be cleaned up when dispose() is called. + Removing previously associated resources is not possible but one can create a + CompositeDisposable, associate it with this + ResourceCompletableObserver and then add/remove resources to/from the CompositeDisposable + freely. + +

    Like all other consumers, ResourceCompletableObserver can be subscribed only once. + Any subsequent attempt to subscribe it to a new source will yield an + IllegalStateException with message "It is not allowed to subscribe with a(n) <class name> multiple times.". + +

    Implementation of onStart(), CompletableObserver.onError(Throwable) + and CompletableObserver.onComplete() are not allowed to throw any unchecked exceptions. + +

    Example

    
+ Disposable d =
+     Completable.complete().delay(1, TimeUnit.SECONDS)
+     .subscribeWith(new ResourceCompletableObserver() {
+         @Override public void onStart() {
+             add(Schedulers.single()
+                 .scheduleDirect(() -> System.out.println("Time!"),
+                     2, TimeUnit.SECONDS));
+         }
+         @Override public void onError(Throwable t) {
+             t.printStackTrace();
+             dispose();
+         }
+         @Override public void onComplete() {
+             System.out.println("Done!");
+             dispose();
+         }
+     });
+ // ...
+ d.dispose();
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ResourceCompletableObserver

        +
        public ResourceCompletableObserver()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        add

        +
        public final void add(@NonNull
+                      @NonNull Disposable resource)
        +
        Adds a resource to this ResourceCompletableObserver.
        +
        +
        Parameters:
        +
        resource - the resource to add
        +
        Throws:
        +
        NullPointerException - if resource is null
        +
        +
        • +
      + + + + + + + +
        +
      • +

        onStart

        +
        protected void onStart()
        +
        Called once the upstream sets a Disposable on this ResourceCompletableObserver. + +

        You can perform initialization at this moment. The default + implementation does nothing.

        +
        • +
      + + + +
        +
      • +

        dispose

        +
        public final void dispose()
        +
        Cancels the main disposable (if any) and disposes the resources associated with + this ResourceCompletableObserver (if any). + +

        This method can be called before the upstream calls onSubscribe(Disposable) at which + case the main Disposable will be immediately disposed.

        +
        +
        Specified by:
        +
        dispose in interface Disposable
        +
        +
        • +
      + + + +
        +
      • +

        isDisposed

        +
        public final boolean isDisposed()
        +
        Returns true if this ResourceCompletableObserver has been disposed/cancelled.
        +
        +
        Specified by:
        +
        isDisposed in interface Disposable
        +
        Returns:
        +
        true if this ResourceCompletableObserver has been disposed/cancelled
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceMaybeObserver.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceMaybeObserver.html new file mode 100644 index 0000000000..46aa11041a --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceMaybeObserver.html @@ -0,0 +1,452 @@ + + + + + +ResourceMaybeObserver (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.observers
+

Class ResourceMaybeObserver<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    All Implemented Interfaces:
    +
    MaybeObserver<T>, Disposable
    +
    +
    +
    +
    public abstract class ResourceMaybeObserver<T>
+extends Object
+implements MaybeObserver<T>, Disposable
    +
    An abstract MaybeObserver that allows asynchronous cancellation of its subscription and associated resources. + +

    All pre-implemented final methods are thread-safe. + +

    Note that MaybeObserver.onSuccess(Object), MaybeObserver.onError(Throwable) and MaybeObserver.onComplete() are + exclusive to each other, unlike a regular Observer, and + onComplete() is never called after an onSuccess(). + +

    Override the protected onStart() to perform initialization when this + ResourceMaybeObserver is subscribed to a source. + +

    Use the public dispose() method to dispose the sequence externally and release + all resources. + +

    To release the associated resources, one has to call dispose() + in onSuccess(), onError() and onComplete() explicitly. + +

    Use add(Disposable) to associate resources (as Disposables) + with this ResourceMaybeObserver that will be cleaned up when dispose() is called. + Removing previously associated resources is not possible but one can create a + CompositeDisposable, associate it with this + ResourceMaybeObserver and then add/remove resources to/from the CompositeDisposable + freely. + +

    Like all other consumers, ResourceMaybeObserver can be subscribed only once. + Any subsequent attempt to subscribe it to a new source will yield an + IllegalStateException with message "It is not allowed to subscribe with a(n) <class name> multiple times.". + +

    Implementation of onStart(), MaybeObserver.onSuccess(Object), MaybeObserver.onError(Throwable) + and MaybeObserver.onComplete() are not allowed to throw any unchecked exceptions. + +

    Example

    
+ Disposable d =
+     Maybe.just(1).delay(1, TimeUnit.SECONDS)
+     .subscribeWith(new ResourceMaybeObserver<Integer>() {
+         @Override public void onStart() {
+             add(Schedulers.single()
+                 .scheduleDirect(() -> System.out.println("Time!"),
+                     2, TimeUnit.SECONDS));
+         }
+         @Override public void onSuccess(Integer t) {
+             System.out.println(t);
+             dispose();
+         }
+         @Override public void onError(Throwable t) {
+             t.printStackTrace();
+             dispose();
+         }
+         @Override public void onComplete() {
+             System.out.println("Done!");
+             dispose();
+         }
+     });
+ // ...
+ d.dispose();
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ResourceMaybeObserver

        +
        public ResourceMaybeObserver()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + + + + + +
        +
      • +

        onStart

        +
        protected void onStart()
        +
        Called once the upstream sets a Disposable on this ResourceMaybeObserver. + +

        You can perform initialization at this moment. The default + implementation does nothing.

        +
        • +
      + + + +
        +
      • +

        dispose

        +
        public final void dispose()
        +
        Cancels the main disposable (if any) and disposes the resources associated with + this ResourceMaybeObserver (if any). + +

        This method can be called before the upstream calls onSubscribe(Disposable) at which + case the main Disposable will be immediately disposed.

        +
        +
        Specified by:
        +
        dispose in interface Disposable
        +
        +
        • +
      + + + +
        +
      • +

        isDisposed

        +
        public final boolean isDisposed()
        +
        Returns true if this ResourceMaybeObserver has been disposed/cancelled.
        +
        +
        Specified by:
        +
        isDisposed in interface Disposable
        +
        Returns:
        +
        true if this ResourceMaybeObserver has been disposed/cancelled
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceObserver.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceObserver.html new file mode 100644 index 0000000000..2a7122291b --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceObserver.html @@ -0,0 +1,449 @@ + + + + + +ResourceObserver (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.observers
+

Class ResourceObserver<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    All Implemented Interfaces:
    +
    Observer<T>, Disposable
    +
    +
    +
    +
    public abstract class ResourceObserver<T>
+extends Object
+implements Observer<T>, Disposable
    +
    An abstract Observer that allows asynchronous cancellation of its subscription and associated resources. + +

    All pre-implemented final methods are thread-safe. + +

    To release the associated resources, one has to call dispose() + in onError() and onComplete() explicitly. + +

    Use add(Disposable) to associate resources (as Disposables) + with this ResourceObserver that will be cleaned up when dispose() is called. + Removing previously associated resources is not possible but one can create a + CompositeDisposable, associate it with this + ResourceObserver and then add/remove resources to/from the CompositeDisposable + freely. + +

    Use the dispose() to dispose the sequence from within an + onNext implementation. + +

    Like all other consumers, ResourceObserver can be subscribed only once. + Any subsequent attempt to subscribe it to a new source will yield an + IllegalStateException with message "It is not allowed to subscribe with a(n) <class name> multiple times.". + +

    Implementation of onStart(), Observer.onNext(Object), Observer.onError(Throwable) + and Observer.onComplete() are not allowed to throw any unchecked exceptions. + If for some reason this can't be avoided, use Observable.safeSubscribe(io.reactivex.rxjava3.core.Observer) + instead of the standard subscribe() method. + +

    Example

    
+ Disposable d =
+     Observable.range(1, 5)
+     .subscribeWith(new ResourceObserver<Integer>() {
+         @Override public void onStart() {
+             add(Schedulers.single()
+                 .scheduleDirect(() -> System.out.println("Time!"),
+                     2, TimeUnit.SECONDS));
+             request(1);
+         }
+         @Override public void onNext(Integer t) {
+             if (t == 3) {
+                 dispose();
+             }
+             System.out.println(t);
+         }
+         @Override public void onError(Throwable t) {
+             t.printStackTrace();
+             dispose();
+         }
+         @Override public void onComplete() {
+             System.out.println("Done!");
+             dispose();
+         }
+     });
+ // ...
+ d.dispose();
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ResourceObserver

        +
        public ResourceObserver()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + + + + + +
        +
      • +

        onStart

        +
        protected void onStart()
        +
        Called once the upstream sets a Disposable on this ResourceObserver. + +

        You can perform initialization at this moment. The default + implementation does nothing.

        +
        • +
      + + + +
        +
      • +

        dispose

        +
        public final void dispose()
        +
        Cancels the main disposable (if any) and disposes the resources associated with + this ResourceObserver (if any). + +

        This method can be called before the upstream calls onSubscribe(Disposable) at which + case the main Disposable will be immediately disposed.

        +
        +
        Specified by:
        +
        dispose in interface Disposable
        +
        +
        • +
      + + + +
        +
      • +

        isDisposed

        +
        public final boolean isDisposed()
        +
        Returns true if this ResourceObserver has been disposed/cancelled.
        +
        +
        Specified by:
        +
        isDisposed in interface Disposable
        +
        Returns:
        +
        true if this ResourceObserver has been disposed/cancelled
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceSingleObserver.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceSingleObserver.html new file mode 100644 index 0000000000..04a1b0906a --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/ResourceSingleObserver.html @@ -0,0 +1,445 @@ + + + + + +ResourceSingleObserver (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.observers
+

Class ResourceSingleObserver<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    All Implemented Interfaces:
    +
    SingleObserver<T>, Disposable
    +
    +
    +
    +
    public abstract class ResourceSingleObserver<T>
+extends Object
+implements SingleObserver<T>, Disposable
    +
    An abstract SingleObserver that allows asynchronous cancellation of its subscription + and the associated resources. + +

    All pre-implemented final methods are thread-safe. + +

    Override the protected onStart() to perform initialization when this + ResourceSingleObserver is subscribed to a source. + +

    Use the public dispose() method to dispose the sequence externally and release + all resources. + +

    To release the associated resources, one has to call dispose() + in onSuccess() and onError() explicitly. + +

    Use add(Disposable) to associate resources (as Disposables) + with this ResourceSingleObserver that will be cleaned up when dispose() is called. + Removing previously associated resources is not possible but one can create a + CompositeDisposable, associate it with this + ResourceSingleObserver and then add/remove resources to/from the CompositeDisposable + freely. + +

    Like all other consumers, ResourceSingleObserver can be subscribed only once. + Any subsequent attempt to subscribe it to a new source will yield an + IllegalStateException with message "It is not allowed to subscribe with a(n) <class name> multiple times.". + +

    Implementation of onStart(), SingleObserver.onSuccess(Object) and SingleObserver.onError(Throwable) + are not allowed to throw any unchecked exceptions. + +

    Example

    
+ Disposable d =
+     Single.just(1).delay(1, TimeUnit.SECONDS)
+     .subscribeWith(new ResourceSingleObserver<Integer>() {
+         @Override public void onStart() {
+             add(Schedulers.single()
+                 .scheduleDirect(() -> System.out.println("Time!"),
+                     2, TimeUnit.SECONDS));
+         }
+         @Override public void onSuccess(Integer t) {
+             System.out.println(t);
+             dispose();
+         }
+         @Override public void onError(Throwable t) {
+             t.printStackTrace();
+             dispose();
+         }
+     });
+ // ...
+ d.dispose();
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ResourceSingleObserver

        +
        public ResourceSingleObserver()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        onSubscribe

        +
        public final void onSubscribe(@NonNull
+                              @NonNull Disposable d)
        +
        Description copied from interface: SingleObserver
        +
        Provides the SingleObserver with the means of cancelling (disposing) the + connection (channel) with the Single in both + synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.
        +
        +
        Specified by:
        +
        onSubscribe in interface SingleObserver<T>
        +
        Parameters:
        +
        d - the Disposable instance whose Disposable.dispose() can + be called anytime to cancel the connection
        +
        +
        • +
      + + + +
        +
      • +

        onStart

        +
        protected void onStart()
        +
        Called once the upstream sets a Disposable on this ResourceSingleObserver. + +

        You can perform initialization at this moment. The default + implementation does nothing.

        +
        • +
      + + + +
        +
      • +

        dispose

        +
        public final void dispose()
        +
        Cancels the main disposable (if any) and disposes the resources associated with + this ResourceSingleObserver (if any). + +

        This method can be called before the upstream calls onSubscribe(Disposable) at which + case the main Disposable will be immediately disposed.

        +
        +
        Specified by:
        +
        dispose in interface Disposable
        +
        +
        • +
      + + + +
        +
      • +

        isDisposed

        +
        public final boolean isDisposed()
        +
        Returns true if this ResourceSingleObserver has been disposed/cancelled.
        +
        +
        Specified by:
        +
        isDisposed in interface Disposable
        +
        Returns:
        +
        true if this ResourceSingleObserver has been disposed/cancelled
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/SafeObserver.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/SafeObserver.html new file mode 100644 index 0000000000..d3de0875b0 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/SafeObserver.html @@ -0,0 +1,435 @@ + + + + + +SafeObserver (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.observers
+

Class SafeObserver<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    All Implemented Interfaces:
    +
    Observer<T>, Disposable
    +
    +
    +
    +
    public final class SafeObserver<T>
+extends Object
+implements Observer<T>, Disposable
    +
    Wraps another Observer and ensures all onXXX methods conform the protocol + (except the requirement for serialized access).
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/SerializedObserver.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/SerializedObserver.html new file mode 100644 index 0000000000..608f22ba8e --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/SerializedObserver.html @@ -0,0 +1,468 @@ + + + + + +SerializedObserver (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.observers
+

Class SerializedObserver<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SerializedObserver

        +
        public SerializedObserver(@NonNull
+                          @NonNull Observer<? super T> downstream)
        +
        Construct a SerializedObserver by wrapping the given actual Observer.
        +
        +
        Parameters:
        +
        downstream - the actual Observer, not null (not verified)
        +
        +
        • +
      + + + +
        +
      • +

        SerializedObserver

        +
        public SerializedObserver(@NonNull
+                          @NonNull Observer<? super T> actual,
+                          boolean delayError)
        +
        Construct a SerializedObserver by wrapping the given actual Observer and + optionally delaying the errors till all regular values have been emitted + from the internal buffer.
        +
        +
        Parameters:
        +
        actual - the actual Observer, not null (not verified)
        +
        delayError - if true, errors are emitted after regular values have been emitted
        +
        +
        • +
      +
      • +
    + + +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/TestObserver.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/TestObserver.html new file mode 100644 index 0000000000..4c9cae2ab0 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/TestObserver.html @@ -0,0 +1,626 @@ + + + + + +TestObserver (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + +
+
io.reactivex.rxjava3.observers
+

Class TestObserver<T>

+
+
+ +
+ +
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/package-frame.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/package-frame.html new file mode 100644 index 0000000000..e480918a04 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/package-frame.html @@ -0,0 +1,35 @@ + + + + + +io.reactivex.rxjava3.observers (RxJava Javadoc 3.1.8) + + + + +

io.reactivex.rxjava3.observers

+
+

Interfaces

+ +

Classes

+ +
+ + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/package-summary.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/package-summary.html new file mode 100644 index 0000000000..8fb48a66cf --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/package-summary.html @@ -0,0 +1,292 @@ + + + + + +io.reactivex.rxjava3.observers (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Package io.reactivex.rxjava3.observers

+
+
Default wrappers and implementations for observer-based consumer classes and interfaces, + including disposable and resource-tracking variants and + the TestObserver that allows unit testing + Observable-, Single-, + Maybe- and Completable-based flows.
+
+

See: Description

+
+
+ + + + +

Package io.reactivex.rxjava3.observers Description

+
Default wrappers and implementations for observer-based consumer classes and interfaces, + including disposable and resource-tracking variants and + the TestObserver that allows unit testing + Observable-, Single-, + Maybe- and Completable-based flows. +

+ Available observer variants +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
The available observer types.
Reactive typeBase interfaceSimpleDisposableResource
ObservableObserverDefaultObserverDisposableObserverDisposableObserver
MaybeMaybeObserverN/ADisposableMaybeObserverDisposableMaybeObserver
SingleSingleObserverN/ADisposableSingleObserverDisposableSingleObserver
CompletableCompletableObserverN/ADisposableCompletableObserverDisposableCompletableObserver

+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/package-tree.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/package-tree.html new file mode 100644 index 0000000000..fd17222da5 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/observers/package-tree.html @@ -0,0 +1,153 @@ + + + + + +io.reactivex.rxjava3.observers Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For Package io.reactivex.rxjava3.observers

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +

Interface Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/ConditionalSubscriber.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/ConditionalSubscriber.html new file mode 100644 index 0000000000..4cee6a46e7 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/ConditionalSubscriber.html @@ -0,0 +1,263 @@ + + + + + +ConditionalSubscriber (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.operators
+

Interface ConditionalSubscriber<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    All Superinterfaces:
    +
    FlowableSubscriber<T>, Subscriber<T>
    +
    +
    +
    +
    public interface ConditionalSubscriber<T>
+extends FlowableSubscriber<T>
    +
    A FlowableSubscriber with an additional tryOnNext(Object) method that + tells the caller the specified value has been accepted or not. + +

    This allows certain queue-drain or source-drain operators + to avoid requesting 1 on behalf of a dropped value.

    +
    +
    Since:
    +
    3.1.1
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        tryOnNext

        +
        boolean tryOnNext(@NonNull
+                  T t)
        +
        Conditionally takes the value.
        +
        +
        Parameters:
        +
        t - the value to deliver
        +
        Returns:
        +
        true if the value has been accepted, false if the value has been rejected + and the next value can be sent immediately
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/QueueDisposable.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/QueueDisposable.html new file mode 100644 index 0000000000..fe3b8f086c --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/QueueDisposable.html @@ -0,0 +1,261 @@ + + + + + +QueueDisposable (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.operators
+

Interface QueueDisposable<T>

+
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/QueueFuseable.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/QueueFuseable.html new file mode 100644 index 0000000000..e86e9271f7 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/QueueFuseable.html @@ -0,0 +1,411 @@ + + + + + +QueueFuseable (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.operators
+

Interface QueueFuseable<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type returned by the SimpleQueue.poll()
    +
    +
    +
    All Superinterfaces:
    +
    SimpleQueue<T>
    +
    +
    +
    All Known Subinterfaces:
    +
    QueueDisposable<T>, QueueSubscription<T>
    +
    +
    +
    +
    public interface QueueFuseable<T>
+extends SimpleQueue<T>
    +
    Represents a SimpleQueue plus the means and constants for requesting a fusion mode.
    +
    +
    Since:
    +
    3.1.1
    +
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + +
      Fields 
      Modifier and TypeField and Description
      static intANY +
      Request any of the SYNC or ASYNC modes.
      +
      static intASYNC +
      Request an asynchronous fusion mode and can be returned by requestFusion(int) + for an accepted mode.
      +
      static intBOUNDARY +
      Used in binary or combination with the other constants as an input to requestFusion(int) + indicating that the SimpleQueue.poll() will be called behind an asynchronous boundary and thus + may change the non-trivial computation locations attached to the SimpleQueue.poll() chain of + fused operators.
      +
      static intNONE +
      Returned by the requestFusion(int) if the upstream doesn't support + the requested mode.
      +
      static intSYNC +
      Request a synchronous fusion mode and can be returned by requestFusion(int) + for an accepted mode.
      +
      +
      • +
    + + +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + + + + + +
        +
      • +

        SYNC

        +
        static final int SYNC
        +
        Request a synchronous fusion mode and can be returned by requestFusion(int) + for an accepted mode. +

        + In synchronous fusion, all upstream values are either already available or is generated + when SimpleQueue.poll() is called synchronously. When the SimpleQueue.poll() returns null, + that is the indication if a terminated stream. + In this mode, the upstream won't call the onXXX methods and callers of + SimpleQueue.poll() should be prepared to catch exceptions. Note that SimpleQueue.poll() has + to be called sequentially (from within a serializing drain-loop).

        +
        +
        See Also:
        +
        Constant Field Values
        +
        +
        • +
      + + + +
        +
      • +

        ASYNC

        +
        static final int ASYNC
        +
        Request an asynchronous fusion mode and can be returned by requestFusion(int) + for an accepted mode. +

        + In asynchronous fusion, upstream values may become available to SimpleQueue.poll() eventually. + Upstream signals onError() and onComplete() as usual but onNext may not actually contain + the upstream value but have null instead. Downstream should treat such onNext as indication + that SimpleQueue.poll() can be called. Note that SimpleQueue.poll() has to be called sequentially + (from within a serializing drain-loop). In addition, callers of SimpleQueue.poll() should be + prepared to catch exceptions.

        +
        +
        See Also:
        +
        Constant Field Values
        +
        +
        • +
      + + + + + + + +
        +
      • +

        BOUNDARY

        +
        static final int BOUNDARY
        +
        Used in binary or combination with the other constants as an input to requestFusion(int) + indicating that the SimpleQueue.poll() will be called behind an asynchronous boundary and thus + may change the non-trivial computation locations attached to the SimpleQueue.poll() chain of + fused operators. +

        + For example, fusing map() and observeOn() may move the computation of the map's function over to + the thread run after the observeOn(), which is generally unexpected.

        +
        +
        See Also:
        +
        Constant Field Values
        +
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        requestFusion

        +
        int requestFusion(int mode)
        +
        Request a fusion mode from the upstream. +

        + This should be called before onSubscribe returns. +

        + Calling this method multiple times or after onSubscribe finished is not allowed + and may result in undefined behavior. +

        +
        +
        Parameters:
        +
        mode - the requested fusion mode, allowed values are SYNC, ASYNC, + ANY combined with BOUNDARY (e.g., requestFusion(SYNC | BOUNDARY)).
        +
        Returns:
        +
        the established fusion mode: NONE, SYNC, ASYNC.
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/QueueSubscription.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/QueueSubscription.html new file mode 100644 index 0000000000..1e79155c88 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/QueueSubscription.html @@ -0,0 +1,264 @@ + + + + + +QueueSubscription (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.operators
+

Interface QueueSubscription<T>

+
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/ScalarSupplier.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/ScalarSupplier.html new file mode 100644 index 0000000000..9782008787 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/ScalarSupplier.html @@ -0,0 +1,258 @@ + + + + + +ScalarSupplier (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.operators
+

Interface ScalarSupplier<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the scalar value type held by the implementing reactive type
    +
    +
    +
    All Superinterfaces:
    +
    Supplier<T>
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface ScalarSupplier<T>
+extends Supplier<T>
    +
    A marker interface indicating that a scalar, constant value + is held by the implementing reactive type which can be + safely extracted during assembly time can be used for + optimization. +

    + Implementors of get() should not throw any exception. +

    + Design note: the interface extends Supplier because if a scalar + is safe to extract during assembly time, it is also safe to extract at + subscription time or later. This allows optimizations to deal with such + single-element sources uniformly. +

    +
    +
    Since:
    +
    3.1.1
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        get

        +
        T get()
        +
        Description copied from interface: Supplier
        +
        Produces a value or throws an exception.
        +
        +
        Specified by:
        +
        get in interface Supplier<T>
        +
        Returns:
        +
        the value produced
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SimplePlainQueue.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SimplePlainQueue.html new file mode 100644 index 0000000000..b2c185f974 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SimplePlainQueue.html @@ -0,0 +1,261 @@ + + + + + +SimplePlainQueue (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.operators
+

Interface SimplePlainQueue<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type to offer and poll, not null
    +
    +
    +
    All Superinterfaces:
    +
    SimpleQueue<T>
    +
    +
    +
    All Known Implementing Classes:
    +
    SpscArrayQueue, SpscLinkedArrayQueue
    +
    +
    +
    +
    public interface SimplePlainQueue<T>
+extends SimpleQueue<T>
    +
    Override of the SimpleQueue interface with no throws Throwable on poll().
    +
    +
    Since:
    +
    3.1.1
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        poll

        +
        @Nullable
+T poll()
        +
        Description copied from interface: SimpleQueue
        +
        Tries to dequeue a value (non-null) or returns null if + the queue is empty. +

        + If the producer uses SimpleQueue.offer(Object, Object) and + when polling in pairs, if the first poll() returns a non-null + item, the second poll() is guaranteed to return a non-null item + as well.

        +
        +
        Specified by:
        +
        poll in interface SimpleQueue<T>
        +
        Returns:
        +
        the item or null to indicate an empty queue
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SimpleQueue.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SimpleQueue.html new file mode 100644 index 0000000000..1e235c7649 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SimpleQueue.html @@ -0,0 +1,354 @@ + + + + + +SimpleQueue (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.operators
+

Interface SimpleQueue<T>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type to offer and poll, not null
    +
    +
    +
    All Known Subinterfaces:
    +
    QueueDisposable<T>, QueueFuseable<T>, QueueSubscription<T>, SimplePlainQueue<T>
    +
    +
    +
    All Known Implementing Classes:
    +
    SpscArrayQueue, SpscLinkedArrayQueue
    +
    +
    +
    +
    public interface SimpleQueue<T>
    +
    A simplified interface for offering, polling and clearing a queue. +

    + This interface does not define most of the Collection + or Queue methods as the intended usage of SimpleQueue + does not require support for iteration or introspection.

    +
    +
    Since:
    +
    3.1.1
    +
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Abstract Methods 
      Modifier and TypeMethod and Description
      voidclear() +
      Removes all enqueued items from this queue.
      +
      booleanisEmpty() +
      Returns true if the queue is empty.
      +
      booleanoffer(T value) +
      Atomically enqueue a single value.
      +
      booleanoffer(T v1, + T v2) +
      Atomically enqueue two values.
      +
      Tpoll() +
      Tries to dequeue a value (non-null) or returns null if + the queue is empty.
      +
      +
      • +
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        offer

        +
        boolean offer(@NonNull
+              T value)
        +
        Atomically enqueue a single value.
        +
        +
        Parameters:
        +
        value - the value to enqueue, not null
        +
        Returns:
        +
        true if successful, false if the value was not enqueued + likely due to reaching the queue capacity)
        +
        +
        • +
      + + + + + +
        +
      • +

        offer

        +
        boolean offer(@NonNull
+              T v1,
+              @NonNull
+              T v2)
        +
        Atomically enqueue two values.
        +
        +
        Parameters:
        +
        v1 - the first value to enqueue, not null
        +
        v2 - the second value to enqueue, not null
        +
        Returns:
        +
        true if successful, false if the value was not enqueued + likely due to reaching the queue capacity)
        +
        +
        • +
      + + + +
        +
      • +

        poll

        +
        @Nullable
+T poll()
+          throws Throwable
        +
        Tries to dequeue a value (non-null) or returns null if + the queue is empty. +

        + If the producer uses offer(Object, Object) and + when polling in pairs, if the first poll() returns a non-null + item, the second poll() is guaranteed to return a non-null item + as well.

        +
        +
        Returns:
        +
        the item or null to indicate an empty queue
        +
        Throws:
        +
        Throwable - if some pre-processing of the dequeued + item (usually through fused functions) throws.
        +
        +
        • +
      + + + +
        +
      • +

        isEmpty

        +
        boolean isEmpty()
        +
        Returns true if the queue is empty. +

        + Note however that due to potential fused functions in poll() + it is possible this method returns false but then poll() returns null + because the fused function swallowed the available item(s).

        +
        +
        Returns:
        +
        true if the queue is empty
        +
        +
        • +
      + + + +
        +
      • +

        clear

        +
        void clear()
        +
        Removes all enqueued items from this queue.
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SpscArrayQueue.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SpscArrayQueue.html new file mode 100644 index 0000000000..7f212694e5 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SpscArrayQueue.html @@ -0,0 +1,442 @@ + + + + + +SpscArrayQueue (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.operators
+

Class SpscArrayQueue<E>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    E - the element type of the queue
    +
    +
    +
    All Implemented Interfaces:
    +
    SimplePlainQueue<E>, SimpleQueue<E>, Serializable
    +
    +
    +
    +
    public final class SpscArrayQueue<E>
+extends AtomicReferenceArray<E>
+implements SimplePlainQueue<E>
    +
    A Single-Producer-Single-Consumer queue backed by a pre-allocated buffer. +

    + This implementation is a mashup of the Fast Flow + algorithm with an optimization of the offer method taken from the BQueue algorithm (a variation on Fast + Flow), and adjusted to comply with Queue.offer semantics with regards to capacity.
    + For convenience the relevant papers are available in the resources folder:
    + 2010 - Pisa - SPSC Queues on Shared Cache Multi-Core Systems.pdf
    + 2012 - Junchang- BQueue- Efficient and Practical Queuing.pdf
    +     This implementation is wait free.

    +
    +
    Since:
    +
    3.1.1
    +
    See Also:
    +
    Serialized Form
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SpscArrayQueue

        +
        public SpscArrayQueue(int capacity)
        +
        Constructs an array-backed queue with the given capacity rounded + up to the next power of 2 size.
        +
        +
        Parameters:
        +
        capacity - the maximum number of elements the queue would hold, + rounded up to the next power of 2
        +
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        offer

        +
        public boolean offer(E e)
        +
        Description copied from interface: SimpleQueue
        +
        Atomically enqueue a single value.
        +
        +
        Specified by:
        +
        offer in interface SimpleQueue<E>
        +
        Parameters:
        +
        e - the value to enqueue, not null
        +
        Returns:
        +
        true if successful, false if the value was not enqueued + likely due to reaching the queue capacity)
        +
        +
        • +
      + + + + + +
        +
      • +

        offer

        +
        public boolean offer(E v1,
+                     E v2)
        +
        Description copied from interface: SimpleQueue
        +
        Atomically enqueue two values.
        +
        +
        Specified by:
        +
        offer in interface SimpleQueue<E>
        +
        Parameters:
        +
        v1 - the first value to enqueue, not null
        +
        v2 - the second value to enqueue, not null
        +
        Returns:
        +
        true if successful, false if the value was not enqueued + likely due to reaching the queue capacity)
        +
        +
        • +
      + + + +
        +
      • +

        poll

        +
        @Nullable
+public E poll()
        +
        Description copied from interface: SimpleQueue
        +
        Tries to dequeue a value (non-null) or returns null if + the queue is empty. +

        + If the producer uses SimpleQueue.offer(Object, Object) and + when polling in pairs, if the first poll() returns a non-null + item, the second poll() is guaranteed to return a non-null item + as well.

        +
        +
        Specified by:
        +
        poll in interface SimplePlainQueue<E>
        +
        Specified by:
        +
        poll in interface SimpleQueue<E>
        +
        Returns:
        +
        the item or null to indicate an empty queue
        +
        +
        • +
      + + + +
        +
      • +

        isEmpty

        +
        public boolean isEmpty()
        +
        Description copied from interface: SimpleQueue
        +
        Returns true if the queue is empty. +

        + Note however that due to potential fused functions in SimpleQueue.poll() + it is possible this method returns false but then poll() returns null + because the fused function swallowed the available item(s).

        +
        +
        Specified by:
        +
        isEmpty in interface SimpleQueue<E>
        +
        Returns:
        +
        true if the queue is empty
        +
        +
        • +
      + + + +
        +
      • +

        clear

        +
        public void clear()
        +
        Description copied from interface: SimpleQueue
        +
        Removes all enqueued items from this queue.
        +
        +
        Specified by:
        +
        clear in interface SimpleQueue<E>
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SpscLinkedArrayQueue.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SpscLinkedArrayQueue.html new file mode 100644 index 0000000000..ab3c79f8c7 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/SpscLinkedArrayQueue.html @@ -0,0 +1,463 @@ + + + + + +SpscLinkedArrayQueue (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.operators
+

Class SpscLinkedArrayQueue<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the contained value type
    +
    +
    +
    All Implemented Interfaces:
    +
    SimplePlainQueue<T>, SimpleQueue<T>
    +
    +
    +
    +
    public final class SpscLinkedArrayQueue<T>
+extends Object
+implements SimplePlainQueue<T>
    +
    A single-producer single-consumer array-backed queue which can allocate new arrays in case the consumer is slower + than the producer.
    +
    +
    Since:
    +
    3.1.1
    +
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Summary

      + + + + + + + + +
      Constructors 
      Constructor and Description
      SpscLinkedArrayQueue(int bufferSize) +
      Constructs a linked array-based queue instance with the given + island size rounded up to the next power of 2.
      +
      +
      • +
    + +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethod and Description
      voidclear() +
      Removes all enqueued items from this queue.
      +
      booleanisEmpty() +
      Returns true if the queue is empty.
      +
      booleanoffer(T e) +
      Atomically enqueue a single value.
      +
      booleanoffer(T first, + T second) +
      Offer two elements at the same time.
      +
      Tpeek() +
      Returns the next element in this queue without removing it or null + if this queue is empty
      +
      Tpoll() +
      Tries to dequeue a value (non-null) or returns null if + the queue is empty.
      +
      intsize() +
      Returns the number of elements in the queue.
      +
      + +
      • +
    +
    • +
+
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SpscLinkedArrayQueue

        +
        public SpscLinkedArrayQueue(int bufferSize)
        +
        Constructs a linked array-based queue instance with the given + island size rounded up to the next power of 2.
        +
        +
        Parameters:
        +
        bufferSize - the maximum number of elements per island
        +
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + + + +
        +
      • +

        offer

        +
        public boolean offer(T e)
        +
        Atomically enqueue a single value. +

        + This implementation is correct for single producer thread use only.

        +
        +
        Specified by:
        +
        offer in interface SimpleQueue<T>
        +
        Parameters:
        +
        e - the value to enqueue, not null
        +
        Returns:
        +
        true if successful, false if the value was not enqueued + likely due to reaching the queue capacity)
        +
        +
        • +
      + + + +
        +
      • +

        poll

        +
        @Nullable
+public T poll()
        +
        Tries to dequeue a value (non-null) or returns null if + the queue is empty. +

        + If the producer uses SimpleQueue.offer(Object, Object) and + when polling in pairs, if the first poll() returns a non-null + item, the second poll() is guaranteed to return a non-null item + as well. +

        + This implementation is correct for single consumer thread use only.

        +
        +
        Specified by:
        +
        poll in interface SimplePlainQueue<T>
        +
        Specified by:
        +
        poll in interface SimpleQueue<T>
        +
        Returns:
        +
        the item or null to indicate an empty queue
        +
        +
        • +
      + + + +
        +
      • +

        peek

        +
        @Nullable
+public T peek()
        +
        Returns the next element in this queue without removing it or null + if this queue is empty
        +
        +
        Returns:
        +
        the next element or null
        +
        +
        • +
      + + + +
        +
      • +

        clear

        +
        public void clear()
        +
        Description copied from interface: SimpleQueue
        +
        Removes all enqueued items from this queue.
        +
        +
        Specified by:
        +
        clear in interface SimpleQueue<T>
        +
        +
        • +
      + + + +
        +
      • +

        size

        +
        public int size()
        +
        Returns the number of elements in the queue.
        +
        +
        Returns:
        +
        the number of elements in the queue
        +
        +
        • +
      + + + +
        +
      • +

        isEmpty

        +
        public boolean isEmpty()
        +
        Description copied from interface: SimpleQueue
        +
        Returns true if the queue is empty. +

        + Note however that due to potential fused functions in SimpleQueue.poll() + it is possible this method returns false but then poll() returns null + because the fused function swallowed the available item(s).

        +
        +
        Specified by:
        +
        isEmpty in interface SimpleQueue<T>
        +
        Returns:
        +
        true if the queue is empty
        +
        +
        • +
      + + + + + +
        +
      • +

        offer

        +
        public boolean offer(T first,
+                     T second)
        +
        Offer two elements at the same time. +

        Don't use the regular offer() with this at all!

        +
        +
        Specified by:
        +
        offer in interface SimpleQueue<T>
        +
        Parameters:
        +
        first - the first value, not null
        +
        second - the second value, not null
        +
        Returns:
        +
        true if the queue accepted the two new values
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/package-frame.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/package-frame.html new file mode 100644 index 0000000000..cf96543e53 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/package-frame.html @@ -0,0 +1,30 @@ + + + + + +io.reactivex.rxjava3.operators (RxJava Javadoc 3.1.8) + + + + +

io.reactivex.rxjava3.operators

+
+

Interfaces

+ +

Classes

+ +
+ + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/package-summary.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/package-summary.html new file mode 100644 index 0000000000..dc442a4383 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/package-summary.html @@ -0,0 +1,216 @@ + + + + + +io.reactivex.rxjava3.operators (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Package io.reactivex.rxjava3.operators

+
+
Classes and interfaces for writing advanced operators within and outside RxJava.
+
+

See: Description

+
+
+ + + + +

Package io.reactivex.rxjava3.operators Description

+
Classes and interfaces for writing advanced operators within and outside RxJava.
+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/package-tree.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/package-tree.html new file mode 100644 index 0000000000..baf31e89ef --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/operators/package-tree.html @@ -0,0 +1,177 @@ + + + + + +io.reactivex.rxjava3.operators Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For Package io.reactivex.rxjava3.operators

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +

Interface Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelFailureHandling.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelFailureHandling.html new file mode 100644 index 0000000000..8d5ab1aa95 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelFailureHandling.html @@ -0,0 +1,409 @@ + + + + + +ParallelFailureHandling (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + +
+
io.reactivex.rxjava3.parallel
+

Enum ParallelFailureHandling

+
+
+ +
+ +
+
+ +
+
+
    +
  • + + + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        values

        +
        public static ParallelFailureHandling[] values()
        +
        Returns an array containing the constants of this enum type, in +the order they are declared. This method may be used to iterate +over the constants as follows: +
        +for (ParallelFailureHandling c : ParallelFailureHandling.values())
+    System.out.println(c);
+
        +
        +
        Returns:
        +
        an array containing the constants of this enum type, in the order they are declared
        +
        +
        • +
      + + + +
        +
      • +

        valueOf

        +
        public static ParallelFailureHandling valueOf(String name)
        +
        Returns the enum constant of this type with the specified name. +The string must match exactly an identifier used to declare an +enum constant in this type. (Extraneous whitespace characters are +not permitted.)
        +
        +
        Parameters:
        +
        name - the name of the enum constant to be returned.
        +
        Returns:
        +
        the enum constant with the specified name
        +
        Throws:
        +
        IllegalArgumentException - if this enum type has no constant with the specified name
        +
        NullPointerException - if the argument is null
        +
        +
        • +
      + + + + +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelFlowable.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelFlowable.html new file mode 100644 index 0000000000..7eec4e3d0e --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelFlowable.html @@ -0,0 +1,2620 @@ + + + + + +ParallelFlowable (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.parallel
+

Class ParallelFlowable<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    +
    public abstract class ParallelFlowable<T>
+extends Object
    +
    Abstract base class for parallel publishing of events signaled to an array of Subscribers. +

    + Use from(Publisher) to start processing a regular Publisher in 'rails'. + Use runOn(Scheduler) to introduce where each 'rail' should run on thread-vise. + Use sequential() to merge the sources back into a single Flowable. + +

    History: 2.0.5 - experimental; 2.1 - beta

    +
    +
    Since:
    +
    2.2
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ParallelFlowable

        +
        public ParallelFlowable()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        subscribe

        +
        @BackpressureSupport(value=SPECIAL)
+ @SchedulerSupport(value="none")
+public abstract void subscribe(@NonNull Subscriber<? super T>[] subscribers)
        +
        Subscribes an array of Subscribers to this ParallelFlowable and triggers + the execution chain for all 'rails'. +
        +
        Backpressure:
        +
        The backpressure behavior/expectation is determined by the supplied Subscriber.
        +
        Scheduler:
        +
        subscribe does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        subscribers - the subscribers array to run in parallel, the number + of items must be equal to the parallelism level of this ParallelFlowable
        +
        Throws:
        +
        NullPointerException - if subscribers is null
        +
        See Also:
        +
        parallelism()
        +
        +
        • +
      + + + +
        +
      • +

        parallelism

        +
        @CheckReturnValue
+public abstract int parallelism()
        +
        Returns the number of expected parallel Subscribers.
        +
        +
        Returns:
        +
        the number of expected parallel Subscribers
        +
        +
        • +
      + + + +
        +
      • +

        validate

        +
        protected final boolean validate(@NonNull Subscriber<?>[] subscribers)
        +
        Validates the number of subscribers and returns true if their number + matches the parallelism level of this ParallelFlowable.
        +
        +
        Parameters:
        +
        subscribers - the array of Subscribers
        +
        Returns:
        +
        true if the number of subscribers equals to the parallelism level
        +
        Throws:
        +
        NullPointerException - if subscribers is null
        +
        IllegalArgumentException - if subscribers.length is different from parallelism()
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        from

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=FULL)
+public static <T> @NonNull ParallelFlowable<T> from(@NonNull Publisher<? extends T> source,
+        int parallelism,
+        int prefetch)
        +
        Take a Publisher and prepare to consume it on parallelism number of 'rails' , + possibly ordered and round-robin fashion and use custom prefetch amount and queue + for dealing with the source Publisher's values. +
        +
        Backpressure:
        +
        The operator honors the backpressure of the parallel rails and + requests the prefetch amount from the upstream, followed + by 75% of that amount requested after every 75% received.
        +
        Scheduler:
        +
        from does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        source - the source Publisher
        +
        parallelism - the number of parallel rails
        +
        prefetch - the number of values to prefetch from the source + the source until there is a rail ready to process it.
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if source is null
        +
        IllegalArgumentException - if parallelism or prefetch is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        map

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=PASS_THROUGH)
+public final <R> @NonNull ParallelFlowable<R> map(@NonNull Function<? super T,? extends R> mapper)
        +
        Maps the source values on each 'rail' to another value. +

        + Note that the same mapper function may be called from multiple threads concurrently. +

        +
        Backpressure:
        +
        The operator is a pass-through for backpressure and the behavior + is determined by the upstream and downstream rail behaviors.
        +
        Scheduler:
        +
        map does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        mapper - the mapper function turning Ts into Rs.
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        +
        • +
      + + + +
        +
      • +

        map

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=PASS_THROUGH)
+public final <R> @NonNull ParallelFlowable<R> map(@NonNull Function<? super T,? extends R> mapper,
+        @NonNull ParallelFailureHandling errorHandler)
        +
        Maps the source values on each 'rail' to another value and + handles errors based on the given ParallelFailureHandling enumeration value. +

        + Note that the same mapper function may be called from multiple threads concurrently. +

        +
        Backpressure:
        +
        The operator is a pass-through for backpressure and the behavior + is determined by the upstream and downstream rail behaviors.
        +
        Scheduler:
        +
        map does not operate by default on a particular Scheduler.
        +
        +

        History: 2.0.8 - experimental

        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        mapper - the mapper function turning Ts into Rs.
        +
        errorHandler - the enumeration that defines how to handle errors thrown + from the mapper function
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper or errorHandler is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        map

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=PASS_THROUGH)
+public final <R> @NonNull ParallelFlowable<R> map(@NonNull Function<? super T,? extends R> mapper,
+        @NonNull BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)
        +
        Maps the source values on each 'rail' to another value and + handles errors based on the returned value by the handler function. +

        + Note that the same mapper function may be called from multiple threads concurrently. +

        +
        Backpressure:
        +
        The operator is a pass-through for backpressure and the behavior + is determined by the upstream and downstream rail behaviors.
        +
        Scheduler:
        +
        map does not operate by default on a particular Scheduler.
        +
        +

        History: 2.0.8 - experimental

        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        mapper - the mapper function turning Ts into Rs.
        +
        errorHandler - the function called with the current repeat count and + failure Throwable and should return one of the ParallelFailureHandling + enumeration values to indicate how to proceed.
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper or errorHandler is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + + + + + +
        +
      • +

        filter

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=PASS_THROUGH)
+public final @NonNull ParallelFlowable<T> filter(@NonNull Predicate<? super T> predicate,
+        @NonNull ParallelFailureHandling errorHandler)
        +
        Filters the source values on each 'rail' and + handles errors based on the given ParallelFailureHandling enumeration value. +

        + Note that the same predicate may be called from multiple threads concurrently. +

        +
        Backpressure:
        +
        The operator is a pass-through for backpressure and the behavior + is determined by the upstream and downstream rail behaviors.
        +
        Scheduler:
        +
        filter does not operate by default on a particular Scheduler.
        +
        +

        History: 2.0.8 - experimental

        +
        +
        Parameters:
        +
        predicate - the function returning true to keep a value or false to drop a value
        +
        errorHandler - the enumeration that defines how to handle errors thrown + from the predicate
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if predicate or errorHandler is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + + + + + +
        +
      • +

        runOn

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+public final @NonNull ParallelFlowable<T> runOn(@NonNull Scheduler scheduler)
        +
        Specifies where each 'rail' will observe its incoming values, specified via a Scheduler, with + no work-stealing and default prefetch amount. +

        + This operator uses the default prefetch size returned by Flowable.bufferSize(). +

        + The operator will call Scheduler.createWorker() as many + times as this ParallelFlowable's parallelism level is. +

        + No assumptions are made about the Scheduler's parallelism level, + if the Scheduler's parallelism level is lower than the ParallelFlowable's, + some rails may end up on the same thread/worker. +

        + This operator doesn't require the Scheduler to be trampolining as it + does its own built-in trampolining logic. +

        +
        Backpressure:
        +
        The operator honors the backpressure of the parallel rails and + requests Flowable.bufferSize() amount from the upstream, followed + by 75% of that amount requested after every 75% received.
        +
        Scheduler:
        +
        runOn drains the upstream rails on the specified Scheduler's + Workers.
        +
        +
        +
        Parameters:
        +
        scheduler - the scheduler to use
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if scheduler is null
        +
        +
        • +
      + + + +
        +
      • +

        runOn

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="custom")
+public final @NonNull ParallelFlowable<T> runOn(@NonNull Scheduler scheduler,
+        int prefetch)
        +
        Specifies where each 'rail' will observe its incoming values, specified via a Scheduler, with + possibly work-stealing and a given prefetch amount. +

        + This operator uses the default prefetch size returned by Flowable.bufferSize(). +

        + The operator will call Scheduler.createWorker() as many + times as this ParallelFlowable's parallelism level is. +

        + No assumptions are made about the Scheduler's parallelism level, + if the Scheduler's parallelism level is lower than the ParallelFlowable's, + some rails may end up on the same thread/worker. +

        + This operator doesn't require the Scheduler to be trampolining as it + does its own built-in trampolining logic. +

        +
        Backpressure:
        +
        The operator honors the backpressure of the parallel rails and + requests the prefetch amount from the upstream, followed + by 75% of that amount requested after every 75% received.
        +
        Scheduler:
        +
        runOn drains the upstream rails on the specified Scheduler's + Workers.
        +
        +
        +
        Parameters:
        +
        scheduler - the scheduler to use + that rail's worker has run out of work.
        +
        prefetch - the number of values to request on each 'rail' from the source
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if scheduler is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        reduce

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final @NonNull Flowable<T> reduce(@NonNull BiFunction<T,T,T> reducer)
        +
        Reduces all values within a 'rail' and across 'rails' with a reducer function into one + Flowable sequence. +

        + Note that the same reducer function may be called from multiple threads concurrently. +

        +
        Backpressure:
        +
        The operator honors backpressure from the downstream and consumes + the upstream rails in an unbounded manner (requesting Long.MAX_VALUE).
        +
        Scheduler:
        +
        reduce does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        reducer - the function to reduce two values into one.
        +
        Returns:
        +
        the new Flowable instance emitting the reduced value or empty if the current ParallelFlowable is empty
        +
        Throws:
        +
        NullPointerException - if reducer is null
        +
        +
        • +
      + + + +
        +
      • +

        reduce

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull ParallelFlowable<R> reduce(@NonNull Supplier<R> initialSupplier,
+        @NonNull BiFunction<R,? super T,R> reducer)
        +
        Reduces all values within a 'rail' to a single value (with a possibly different type) via + a reducer function that is initialized on each rail from an initialSupplier value. +

        + Note that the same mapper function may be called from multiple threads concurrently. +

        +
        Backpressure:
        +
        The operator honors backpressure from the downstream rails and consumes + the upstream rails in an unbounded manner (requesting Long.MAX_VALUE).
        +
        Scheduler:
        +
        reduce does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the reduced output type
        +
        Parameters:
        +
        initialSupplier - the supplier for the initial value
        +
        reducer - the function to reduce a previous output of reduce (or the initial value supplied) + with a current source value.
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if initialSupplier or reducer is null
        +
        +
        • +
      + + + + + + + +
        +
      • +

        sequential

        +
        @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @CheckReturnValue
+ @NonNull
+public final @NonNull Flowable<T> sequential(int prefetch)
        +
        Merges the values from each 'rail' in a round-robin or same-order fashion and + exposes it as a regular Flowable sequence, running with a give prefetch value + for the rails. + +
        +
        Backpressure:
        +
        The operator honors backpressure from the downstream and + requests the prefetch amount from each rail, then + requests from each rail 75% of this amount after 75% received.
        +
        Scheduler:
        +
        sequential does not operate by default on a particular Scheduler.
        +
        +
        +
        Parameters:
        +
        prefetch - the prefetch amount to use for each rail
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        See Also:
        +
        sequential(), +sequentialDelayError(int)
        +
        +
        • +
      + + + +
        +
      • +

        sequentialDelayError

        +
        @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @CheckReturnValue
+ @NonNull
+public final @NonNull Flowable<T> sequentialDelayError()
        +
        Merges the values from each 'rail' in a round-robin or same-order fashion and + exposes it as a regular Flowable sequence, running with a default prefetch value + for the rails and delaying errors from all rails till all terminate. +

        + This operator uses the default prefetch size returned by Flowable.bufferSize(). + +

        +
        Backpressure:
        +
        The operator honors backpressure from the downstream and + requests Flowable.bufferSize() amount from each rail, then + requests from each rail 75% of this amount after 75% received.
        +
        Scheduler:
        +
        sequentialDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.0.7 - experimental

        +
        +
        Returns:
        +
        the new Flowable instance
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        sequentialDelayError(int), +sequential()
        +
        +
        • +
      + + + +
        +
      • +

        sequentialDelayError

        +
        @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @CheckReturnValue
+ @NonNull
+public final @NonNull Flowable<T> sequentialDelayError(int prefetch)
        +
        Merges the values from each 'rail' in a round-robin or same-order fashion and + exposes it as a regular Flowable sequence, running with a give prefetch value + for the rails and delaying errors from all rails till all terminate. + +
        +
        Backpressure:
        +
        The operator honors backpressure from the downstream and + requests the prefetch amount from each rail, then + requests from each rail 75% of this amount after 75% received.
        +
        Scheduler:
        +
        sequentialDelayError does not operate by default on a particular Scheduler.
        +
        +

        History: 2.0.7 - experimental

        +
        +
        Parameters:
        +
        prefetch - the prefetch amount to use for each rail
        +
        Returns:
        +
        the new Flowable instance
        +
        Throws:
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        Since:
        +
        2.2
        +
        See Also:
        +
        sequential(), +sequentialDelayError()
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        collect

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=UNBOUNDED_IN)
+ @SchedulerSupport(value="none")
+public final <C> @NonNull ParallelFlowable<C> collect(@NonNull Supplier<? extends C> collectionSupplier,
+        @NonNull BiConsumer<? super C,? super T> collector)
        +
        Collect the elements in each rail into a collection supplied via a collectionSupplier + and collected into with a collector action, emitting the collection at the end. +
        +
        Backpressure:
        +
        The operator honors backpressure from the downstream rails and + consumes the upstream rails in an unbounded manner (requesting Long.MAX_VALUE).
        +
        Scheduler:
        +
        map does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        C - the collection type
        +
        Parameters:
        +
        collectionSupplier - the supplier of the collection in each rail
        +
        collector - the collector, taking the per-rail collection and the current item
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if collectionSupplier or collector is null
        +
        +
        • +
      + + + + + + + +
        +
      • +

        to

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public final <R> R to(@NonNull ParallelFlowableConverter<T,R> converter)
        +
        Calls the specified converter function during assembly time and returns its resulting value. +

        + This allows fluent conversion to any other type. +

        +
        Backpressure:
        +
        The operator is a pass-through for backpressure and the behavior + is determined by how the converter function composes over the upstream source.
        +
        Scheduler:
        +
        to does not operate by default on a particular Scheduler.
        +
        +

        History: 2.1.7 - experimental

        +
        +
        Type Parameters:
        +
        R - the resulting object type
        +
        Parameters:
        +
        converter - the function that receives the current ParallelFlowable instance and returns a value
        +
        Returns:
        +
        the converted value
        +
        Throws:
        +
        NullPointerException - if converter is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        compose

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=PASS_THROUGH)
+ @SchedulerSupport(value="none")
+public final <U> @NonNull ParallelFlowable<U> compose(@NonNull ParallelTransformer<T,U> composer)
        +
        Allows composing operators, in assembly time, on top of this ParallelFlowable + and returns another ParallelFlowable with composed features. +
        +
        Backpressure:
        +
        The operator is a pass-through for backpressure and the behavior + is determined by how the converter function composes over the upstream source.
        +
        Scheduler:
        +
        compose does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        U - the output value type
        +
        Parameters:
        +
        composer - the composer function from ParallelFlowable (this) to another ParallelFlowable
        +
        Returns:
        +
        the ParallelFlowable returned by the function
        +
        Throws:
        +
        NullPointerException - if composer is null
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull ParallelFlowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)
        +
        Generates and flattens Publishers on each 'rail'. +

        + The errors are not delayed and uses unbounded concurrency along with default inner prefetch. +

        +
        Backpressure:
        +
        The operator honors backpressure from the downstream rails and + requests Flowable.bufferSize() amount from each rail upfront + and keeps requesting as many items per rail as many inner sources on + that rail completed. The inner sources are requested Flowable.bufferSize() + amount upfront, then 75% of this amount requested after 75% received.
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result type
        +
        Parameters:
        +
        mapper - the function to map each rail's value into a Publisher
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull ParallelFlowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        boolean delayError)
        +
        Generates and flattens Publishers on each 'rail', optionally delaying errors. +

        + It uses unbounded concurrency along with default inner prefetch. +

        +
        Backpressure:
        +
        The operator honors backpressure from the downstream rails and + requests Flowable.bufferSize() amount from each rail upfront + and keeps requesting as many items per rail as many inner sources on + that rail completed. The inner sources are requested Flowable.bufferSize() + amount upfront, then 75% of this amount requested after 75% received. +
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result type
        +
        Parameters:
        +
        mapper - the function to map each rail's value into a Publisher
        +
        delayError - should the errors from the main and the inner sources delayed till everybody terminates?
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull ParallelFlowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        boolean delayError,
+        int maxConcurrency)
        +
        Generates and flattens Publishers on each 'rail', optionally delaying errors + and having a total number of simultaneous subscriptions to the inner Publishers. +

        + It uses a default inner prefetch. +

        +
        Backpressure:
        +
        The operator honors backpressure from the downstream rails and + requests maxConcurrency amount from each rail upfront + and keeps requesting as many items per rail as many inner sources on + that rail completed. The inner sources are requested Flowable.bufferSize() + amount upfront, then 75% of this amount requested after 75% received. +
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result type
        +
        Parameters:
        +
        mapper - the function to map each rail's value into a Publisher
        +
        delayError - should the errors from the main and the inner sources delayed till everybody terminates?
        +
        maxConcurrency - the maximum number of simultaneous subscriptions to the generated inner Publishers
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if maxConcurrency is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        flatMap

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull ParallelFlowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        boolean delayError,
+        int maxConcurrency,
+        int prefetch)
        +
        Generates and flattens Publishers on each 'rail', optionally delaying errors, + having a total number of simultaneous subscriptions to the inner Publishers + and using the given prefetch amount for the inner Publishers. +
        +
        Backpressure:
        +
        The operator honors backpressure from the downstream rails and + requests maxConcurrency amount from each rail upfront + and keeps requesting as many items per rail as many inner sources on + that rail completed. The inner sources are requested the prefetch + amount upfront, then 75% of this amount requested after 75% received. +
        +
        Scheduler:
        +
        flatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result type
        +
        Parameters:
        +
        mapper - the function to map each rail's value into a Publisher
        +
        delayError - should the errors from the main and the inner sources delayed till everybody terminates?
        +
        maxConcurrency - the maximum number of simultaneous subscriptions to the generated inner Publishers
        +
        prefetch - the number of items to prefetch from each inner Publisher
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if maxConcurrency or prefetch is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        concatMap

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull ParallelFlowable<R> concatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)
        +
        Generates and concatenates Publishers on each 'rail', signalling errors immediately + and generating 2 publishers upfront. +
        +
        Backpressure:
        +
        The operator honors backpressure from the downstream rails and + requests 2 from each rail upfront and keeps requesting 1 when the inner source complete. + Requests for the inner sources are determined by the downstream rails' + backpressure behavior.
        +
        Scheduler:
        +
        concatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result type
        +
        Parameters:
        +
        mapper - the function to map each rail's value into a Publisher + source and the inner Publishers (immediate, boundary, end)
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        +
        • +
      + + + +
        +
      • +

        concatMap

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull ParallelFlowable<R> concatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        int prefetch)
        +
        Generates and concatenates Publishers on each 'rail', signalling errors immediately + and using the given prefetch amount for generating Publishers upfront. +
        +
        Backpressure:
        +
        The operator honors backpressure from the downstream rails and + requests the prefetch amount from each rail upfront and keeps + requesting 75% of this amount after 75% received and the inner sources completed. + Requests for the inner sources are determined by the downstream rails' + backpressure behavior.
        +
        Scheduler:
        +
        concatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result type
        +
        Parameters:
        +
        mapper - the function to map each rail's value into a Publisher
        +
        prefetch - the number of items to prefetch from each inner Publisher + source and the inner Publishers (immediate, boundary, end)
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        concatMapDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull ParallelFlowable<R> concatMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        boolean tillTheEnd)
        +
        Generates and concatenates Publishers on each 'rail', optionally delaying errors + and generating 2 publishers upfront. +
        +
        Backpressure:
        +
        The operator honors backpressure from the downstream rails and + requests 2 from each rail upfront and keeps requesting 1 when the inner source complete. + Requests for the inner sources are determined by the downstream rails' + backpressure behavior.
        +
        Scheduler:
        +
        concatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result type
        +
        Parameters:
        +
        mapper - the function to map each rail's value into a Publisher
        +
        tillTheEnd - if true, all errors from the upstream and inner Publishers are delayed + till all of them terminate, if false, the error is emitted when an inner Publisher terminates. + source and the inner Publishers (immediate, boundary, end)
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        +
        • +
      + + + +
        +
      • +

        concatMapDelayError

        +
        @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final <R> @NonNull ParallelFlowable<R> concatMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
+        int prefetch,
+        boolean tillTheEnd)
        +
        Generates and concatenates Publishers on each 'rail', optionally delaying errors + and using the given prefetch amount for generating Publishers upfront. +
        +
        Backpressure:
        +
        The operator honors backpressure from the downstream rails and + requests the prefetch amount from each rail upfront and keeps + requesting 75% of this amount after 75% received and the inner sources completed. + Requests for the inner sources are determined by the downstream rails' + backpressure behavior.
        +
        Scheduler:
        +
        concatMap does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the result type
        +
        Parameters:
        +
        mapper - the function to map each rail's value into a Publisher
        +
        prefetch - the number of items to prefetch from each inner Publisher
        +
        tillTheEnd - if true, all errors from the upstream and inner Publishers are delayed + till all of them terminate, if false, the error is emitted when an inner Publisher terminates.
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        mapOptional

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=PASS_THROUGH)
+public final <R> @NonNull ParallelFlowable<R> mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper)
        +
        Maps the source values on each 'rail' to an optional and emits its value if any. +

        + Note that the same mapper function may be called from multiple threads concurrently. +

        +
        Backpressure:
        +
        The operator is a pass-through for backpressure and the behavior + is determined by the upstream and downstream rail behaviors.
        +
        Scheduler:
        +
        map does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        mapper - the mapper function turning Ts into optional of Rs.
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        mapOptional

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=PASS_THROUGH)
+public final <R> @NonNull ParallelFlowable<R> mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper,
+        @NonNull ParallelFailureHandling errorHandler)
        +
        Maps the source values on each 'rail' to an optional and emits its value if any and + handles errors based on the given ParallelFailureHandling enumeration value. +

        + Note that the same mapper function may be called from multiple threads concurrently. +

        +
        Backpressure:
        +
        The operator is a pass-through for backpressure and the behavior + is determined by the upstream and downstream rail behaviors.
        +
        Scheduler:
        +
        map does not operate by default on a particular Scheduler.
        +
        +

        History: 2.0.8 - experimental

        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        mapper - the mapper function turning Ts into optional of Rs.
        +
        errorHandler - the enumeration that defines how to handle errors thrown + from the mapper function
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper or errorHandler is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        mapOptional

        +
        @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(value="none")
+ @BackpressureSupport(value=PASS_THROUGH)
+public final <R> @NonNull ParallelFlowable<R> mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper,
+        @NonNull BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)
        +
        Maps the source values on each 'rail' to an optional and emits its value if any and + handles errors based on the returned value by the handler function. +

        + Note that the same mapper function may be called from multiple threads concurrently. +

        +
        Backpressure:
        +
        The operator is a pass-through for backpressure and the behavior + is determined by the upstream and downstream rail behaviors.
        +
        Scheduler:
        +
        map does not operate by default on a particular Scheduler.
        +
        +

        History: 2.0.8 - experimental

        +
        +
        Type Parameters:
        +
        R - the output value type
        +
        Parameters:
        +
        mapper - the mapper function turning Ts into optional of Rs.
        +
        errorHandler - the function called with the current repeat count and + failure Throwable and should return one of the ParallelFailureHandling + enumeration values to indicate how to proceed.
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper or errorHandler is null
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        flatMapStream

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull ParallelFlowable<R> flatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper)
        +
        Maps each upstream item on each rail into a Stream and emits the Stream's items to the downstream in a sequential fashion. +

        + +

        + Due to the blocking and sequential nature of Java Streams, the streams are mapped and consumed in a sequential fashion + without interleaving (unlike a more general flatMap(Function)). Therefore, flatMapStream and + concatMapStream are identical operators and are provided as aliases. +

        + The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when + closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). + If a Stream should not be closed, turn it into an Iterable and use flatMapIterable(Function): + 

        
+ source.flatMapIterable(v -> createStream(v)::iterator);
+
        +

        + Note that Streams can be consumed only once; any subsequent attempt to consume a Stream + will result in an IllegalStateException. +

        + Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): + 

        
+ source.flatMapStream(v -> IntStream.rangeClosed(v + 1, v + 10).boxed());
+
        +

        + Stream does not support concurrent usage so creating and/or consuming the same instance multiple times + from multiple threads can lead to undefined behavior. +

        +
        Backpressure:
        +
        The operator honors the downstream backpressure and consumes the inner stream only on demand. The operator + prefetches Flowable.bufferSize() items of the upstream (then 75% of it after the 75% received) + and caches them until they are ready to be mapped into Streams + after the current Stream has been consumed.
        +
        Scheduler:
        +
        flatMapStream does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the Streams and the result
        +
        Parameters:
        +
        mapper - the function that receives an upstream item and should return a Stream whose elements + will be emitted to the downstream
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        flatMap(Function), +flatMapIterable(Function), +flatMapStream(Function, int)
        +
        +
        • +
      + + + +
        +
      • +

        flatMapStream

        +
        @CheckReturnValue
+ @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+ @NonNull
+public final <R> @NonNull ParallelFlowable<R> flatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper,
+        int prefetch)
        +
        Maps each upstream item of each rail into a Stream and emits the Stream's items to the downstream in a sequential fashion. +

        + +

        + Due to the blocking and sequential nature of Java Streams, the streams are mapped and consumed in a sequential fashion + without interleaving (unlike a more general flatMap(Function)). Therefore, flatMapStream and + concatMapStream are identical operators and are provided as aliases. +

        + The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when + closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). + If a Stream should not be closed, turn it into an Iterable and use flatMapIterable(Function, int): + 

        
+ source.flatMapIterable(v -> createStream(v)::iterator, 32);
+
        +

        + Note that Streams can be consumed only once; any subsequent attempt to consume a Stream + will result in an IllegalStateException. +

        + Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): + 

        
+ source.flatMapStream(v -> IntStream.rangeClosed(v + 1, v + 10).boxed(), 32);
+
        +

        + Stream does not support concurrent usage so creating and/or consuming the same instance multiple times + from multiple threads can lead to undefined behavior. +

        +
        Backpressure:
        +
        The operator honors the downstream backpressure and consumes the inner stream only on demand. The operator + prefetches the given amount of upstream items and caches them until they are ready to be mapped into Streams + after the current Stream has been consumed.
        +
        Scheduler:
        +
        flatMapStream does not operate by default on a particular Scheduler.
        +
        +
        +
        Type Parameters:
        +
        R - the element type of the Streams and the result
        +
        Parameters:
        +
        mapper - the function that receives an upstream item and should return a Stream whose elements + will be emitted to the downstream
        +
        prefetch - the number of upstream items to request upfront, then 75% of this amount after each 75% upstream items received
        +
        Returns:
        +
        the new ParallelFlowable instance
        +
        Throws:
        +
        NullPointerException - if mapper is null
        +
        IllegalArgumentException - if prefetch is non-positive
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        flatMap(Function, boolean, int), +flatMapIterable(Function, int)
        +
        +
        • +
      + + + + +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelFlowableConverter.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelFlowableConverter.html new file mode 100644 index 0000000000..9c4ea7137a --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelFlowableConverter.html @@ -0,0 +1,246 @@ + + + + + +ParallelFlowableConverter (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.parallel
+

Interface ParallelFlowableConverter<T,R>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    T - the upstream type
    +
    R - the output type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface ParallelFlowableConverter<T,R>
    +
    Convenience interface and callback used by the ParallelFlowable.to(io.reactivex.rxjava3.parallel.ParallelFlowableConverter<T, R>) operator to turn a ParallelFlowable into + another value fluently. +

    History: 2.1.7 - experimental

    +
    +
    Since:
    +
    2.2
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        apply

        +
        @NonNull
+R apply(@NonNull
+                 @NonNull ParallelFlowable<T> upstream)
        +
        Applies a function to the upstream ParallelFlowable and returns a converted value of type R.
        +
        +
        Parameters:
        +
        upstream - the upstream ParallelFlowable instance
        +
        Returns:
        +
        the converted value
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelTransformer.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelTransformer.html new file mode 100644 index 0000000000..6dbe38bb8e --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/ParallelTransformer.html @@ -0,0 +1,247 @@ + + + + + +ParallelTransformer (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.parallel
+

Interface ParallelTransformer<Upstream,Downstream>

+
+
+
+
    +
  • +
    +
    Type Parameters:
    +
    Upstream - the upstream value type
    +
    Downstream - the downstream value type
    +
    +
    +
    Functional Interface:
    +
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    +
    +
    +
    +
    @FunctionalInterface
+public interface ParallelTransformer<Upstream,Downstream>
    +
    Interface to compose ParallelFlowable. +

    History: 2.0.8 - experimental

    +
    +
    Since:
    +
    2.2
    +
    +
    • +
+
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/package-frame.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/package-frame.html new file mode 100644 index 0000000000..456e026c0d --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/package-frame.html @@ -0,0 +1,28 @@ + + + + + +io.reactivex.rxjava3.parallel (RxJava Javadoc 3.1.8) + + + + +

io.reactivex.rxjava3.parallel

+
+

Interfaces

+ +

Classes

+ +

Enums

+ +
+ + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/package-summary.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/package-summary.html new file mode 100644 index 0000000000..dfd5df4a40 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/package-summary.html @@ -0,0 +1,193 @@ + + + + + +io.reactivex.rxjava3.parallel (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Package io.reactivex.rxjava3.parallel

+
+
Contains the base type ParallelFlowable, + a sub-DSL for working with Flowable sequences in parallel.
+
+

See: Description

+
+
+ + + + +

Package io.reactivex.rxjava3.parallel Description

+
Contains the base type ParallelFlowable, + a sub-DSL for working with Flowable sequences in parallel.
+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/package-tree.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/package-tree.html new file mode 100644 index 0000000000..ba9a13f5a7 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/parallel/package-tree.html @@ -0,0 +1,151 @@ + + + + + +io.reactivex.rxjava3.parallel Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For Package io.reactivex.rxjava3.parallel

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +

Interface Hierarchy

+ +

Enum Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/RxJavaPlugins.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/RxJavaPlugins.html new file mode 100644 index 0000000000..c81d57aaf2 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/RxJavaPlugins.html @@ -0,0 +1,2185 @@ + + + + + +RxJavaPlugins (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.plugins
+

Class RxJavaPlugins

+
+
+ +
+
    +
  • +
    +
    +
    public final class RxJavaPlugins
+extends Object
    +
    Utility class to inject handlers to certain standard RxJava operations.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        lockdown

        +
        public static void lockdown()
        +
        Prevents changing the plugins from then on. +

        This allows container-like environments to prevent clients + messing with plugins.

        +
        • +
      + + + +
        +
      • +

        isLockdown

        +
        public static boolean isLockdown()
        +
        Returns true if the plugins were locked down.
        +
        +
        Returns:
        +
        true if the plugins were locked down
        +
        +
        • +
      + + + +
        +
      • +

        setFailOnNonBlockingScheduler

        +
        public static void setFailOnNonBlockingScheduler(boolean enable)
        +
        Enables or disables the blockingX operators to fail + with an IllegalStateException on a non-blocking + scheduler such as computation or single. +

        History: 2.0.5 - experimental

        +
        +
        Parameters:
        +
        enable - enable or disable the feature
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + +
        +
      • +

        isFailOnNonBlockingScheduler

        +
        public static boolean isFailOnNonBlockingScheduler()
        +
        Returns true if the blockingX operators fail + with an IllegalStateException on a non-blocking scheduler + such as computation or single. +

        History: 2.0.5 - experimental

        +
        +
        Returns:
        +
        true if the blockingX operators fail on a non-blocking scheduler
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + +
        +
      • +

        getComputationSchedulerHandler

        +
        @Nullable
+public static @Nullable Function<? super Scheduler,? extends Scheduler> getComputationSchedulerHandler()
        +
        Returns the current hook function.
        +
        +
        Returns:
        +
        the hook function, may be null
        +
        +
        • +
      + + + +
        +
      • +

        getErrorHandler

        +
        @Nullable
+public static @Nullable Consumer<? super Throwable> getErrorHandler()
        +
        Returns the a hook consumer.
        +
        +
        Returns:
        +
        the hook consumer, may be null
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        getIoSchedulerHandler

        +
        @Nullable
+public static @Nullable Function<? super Scheduler,? extends Scheduler> getIoSchedulerHandler()
        +
        Returns the current hook function.
        +
        +
        Returns:
        +
        the hook function, may be null
        +
        +
        • +
      + + + +
        +
      • +

        getNewThreadSchedulerHandler

        +
        @Nullable
+public static @Nullable Function<? super Scheduler,? extends Scheduler> getNewThreadSchedulerHandler()
        +
        Returns the current hook function.
        +
        +
        Returns:
        +
        the hook function, may be null
        +
        +
        • +
      + + + +
        +
      • +

        getScheduleHandler

        +
        @Nullable
+public static @Nullable Function<? super Runnable,? extends Runnable> getScheduleHandler()
        +
        Returns the current hook function.
        +
        +
        Returns:
        +
        the hook function, may be null
        +
        +
        • +
      + + + +
        +
      • +

        getSingleSchedulerHandler

        +
        @Nullable
+public static @Nullable Function<? super Scheduler,? extends Scheduler> getSingleSchedulerHandler()
        +
        Returns the current hook function.
        +
        +
        Returns:
        +
        the hook function, may be null
        +
        +
        • +
      + + + +
        +
      • +

        initComputationScheduler

        +
        @NonNull
+public static @NonNull Scheduler initComputationScheduler(@NonNull Supplier<Scheduler> defaultScheduler)
        +
        Calls the associated hook function.
        +
        +
        Parameters:
        +
        defaultScheduler - a Supplier which returns the hook's input value
        +
        Returns:
        +
        the value returned by the hook, not null
        +
        Throws:
        +
        NullPointerException - if the supplier parameter or its result are null
        +
        +
        • +
      + + + + + + + +
        +
      • +

        initNewThreadScheduler

        +
        @NonNull
+public static @NonNull Scheduler initNewThreadScheduler(@NonNull Supplier<Scheduler> defaultScheduler)
        +
        Calls the associated hook function.
        +
        +
        Parameters:
        +
        defaultScheduler - a Supplier which returns the hook's input value
        +
        Returns:
        +
        the value returned by the hook, not null
        +
        Throws:
        +
        NullPointerException - if the supplier parameter or its result are null
        +
        +
        • +
      + + + +
        +
      • +

        initSingleScheduler

        +
        @NonNull
+public static @NonNull Scheduler initSingleScheduler(@NonNull Supplier<Scheduler> defaultScheduler)
        +
        Calls the associated hook function.
        +
        +
        Parameters:
        +
        defaultScheduler - a Supplier which returns the hook's input value
        +
        Returns:
        +
        the value returned by the hook, not null
        +
        Throws:
        +
        NullPointerException - if the supplier parameter or its result are null
        +
        +
        • +
      + + + +
        +
      • +

        onComputationScheduler

        +
        @NonNull
+public static @NonNull Scheduler onComputationScheduler(@NonNull Scheduler defaultScheduler)
        +
        Calls the associated hook function.
        +
        +
        Parameters:
        +
        defaultScheduler - the hook's input value
        +
        Returns:
        +
        the value returned by the hook
        +
        +
        • +
      + + + +
        +
      • +

        onError

        +
        public static void onError(@NonNull Throwable error)
        +
        Called when an undeliverable error occurs. +

        + Undeliverable errors are those Observer.onError() invocations that are not allowed to happen on + the given consumer type (Observer, Subscriber, etc.) due to protocol restrictions + because the consumer has either disposed/cancelled its Disposable/Subscription or + has already terminated with an onError() or onComplete() signal. +

        + By default, this global error handler prints the stacktrace via Throwable.printStackTrace() + and calls Thread.UncaughtExceptionHandler.uncaughtException(Thread, Throwable) + on the current thread. +

        + Note that on some platforms, the platform runtime terminates the current application with an error if such + uncaught exceptions happen. In this case, it is recommended the application installs a global error + handler via the setErrorHandler(Consumer) plugin method.

        +
        +
        Parameters:
        +
        error - the error to report
        +
        See Also:
        +
        getErrorHandler(), +setErrorHandler(Consumer), +Error handling Wiki
        +
        +
        • +
      + + + +
        +
      • +

        onIoScheduler

        +
        @NonNull
+public static @NonNull Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler)
        +
        Calls the associated hook function.
        +
        +
        Parameters:
        +
        defaultScheduler - the hook's input value
        +
        Returns:
        +
        the value returned by the hook
        +
        +
        • +
      + + + +
        +
      • +

        onNewThreadScheduler

        +
        @NonNull
+public static @NonNull Scheduler onNewThreadScheduler(@NonNull Scheduler defaultScheduler)
        +
        Calls the associated hook function.
        +
        +
        Parameters:
        +
        defaultScheduler - the hook's input value
        +
        Returns:
        +
        the value returned by the hook
        +
        +
        • +
      + + + +
        +
      • +

        onSchedule

        +
        @NonNull
+public static @NonNull Runnable onSchedule(@NonNull Runnable run)
        +
        Called when a task is scheduled.
        +
        +
        Parameters:
        +
        run - the runnable instance
        +
        Returns:
        +
        the replacement runnable
        +
        +
        • +
      + + + +
        +
      • +

        onSingleScheduler

        +
        @NonNull
+public static @NonNull Scheduler onSingleScheduler(@NonNull Scheduler defaultScheduler)
        +
        Calls the associated hook function.
        +
        +
        Parameters:
        +
        defaultScheduler - the hook's input value
        +
        Returns:
        +
        the value returned by the hook
        +
        +
        • +
      + + + +
        +
      • +

        reset

        +
        public static void reset()
        +
        Removes all handlers and resets to default behavior.
        +
        • +
      + + + +
        +
      • +

        setComputationSchedulerHandler

        +
        public static void setComputationSchedulerHandler(@Nullable Function<? super Scheduler,? extends Scheduler> handler)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        handler - the hook function to set, null allowed
        +
        +
        • +
      + + + +
        +
      • +

        setErrorHandler

        +
        public static void setErrorHandler(@Nullable Consumer<? super Throwable> handler)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        handler - the hook function to set, null allowed
        +
        +
        • +
      + + + +
        +
      • +

        setInitComputationSchedulerHandler

        +
        public static void setInitComputationSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>,? extends Scheduler> handler)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        handler - the hook function to set, null allowed, but the function may not return null
        +
        +
        • +
      + + + +
        +
      • +

        setInitIoSchedulerHandler

        +
        public static void setInitIoSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>,? extends Scheduler> handler)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        handler - the hook function to set, null allowed, but the function may not return null
        +
        +
        • +
      + + + +
        +
      • +

        setInitNewThreadSchedulerHandler

        +
        public static void setInitNewThreadSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>,? extends Scheduler> handler)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        handler - the hook function to set, null allowed, but the function may not return null
        +
        +
        • +
      + + + +
        +
      • +

        setInitSingleSchedulerHandler

        +
        public static void setInitSingleSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>,? extends Scheduler> handler)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        handler - the hook function to set, null allowed, but the function may not return null
        +
        +
        • +
      + + + +
        +
      • +

        setIoSchedulerHandler

        +
        public static void setIoSchedulerHandler(@Nullable Function<? super Scheduler,? extends Scheduler> handler)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        handler - the hook function to set, null allowed
        +
        +
        • +
      + + + +
        +
      • +

        setNewThreadSchedulerHandler

        +
        public static void setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler,? extends Scheduler> handler)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        handler - the hook function to set, null allowed
        +
        +
        • +
      + + + +
        +
      • +

        setScheduleHandler

        +
        public static void setScheduleHandler(@Nullable Function<? super Runnable,? extends Runnable> handler)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        handler - the hook function to set, null allowed
        +
        +
        • +
      + + + +
        +
      • +

        setSingleSchedulerHandler

        +
        public static void setSingleSchedulerHandler(@Nullable Function<? super Scheduler,? extends Scheduler> handler)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        handler - the hook function to set, null allowed
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        getOnFlowableAssembly

        +
        @Nullable
+public static @Nullable Function<? super Flowable,? extends Flowable> getOnFlowableAssembly()
        +
        Returns the current hook function.
        +
        +
        Returns:
        +
        the hook function, may be null
        +
        +
        • +
      + + + + + + + + + + + + + + + +
        +
      • +

        getOnMaybeAssembly

        +
        @Nullable
+public static @Nullable Function<? super Maybe,? extends Maybe> getOnMaybeAssembly()
        +
        Returns the current hook function.
        +
        +
        Returns:
        +
        the hook function, may be null
        +
        +
        • +
      + + + +
        +
      • +

        getOnSingleAssembly

        +
        @Nullable
+public static @Nullable Function<? super Single,? extends Single> getOnSingleAssembly()
        +
        Returns the current hook function.
        +
        +
        Returns:
        +
        the hook function, may be null
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + +
        +
      • +

        setOnCompletableAssembly

        +
        public static void setOnCompletableAssembly(@Nullable Function<? super Completable,? extends Completable> onCompletableAssembly)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        onCompletableAssembly - the hook function to set, null allowed
        +
        +
        • +
      + + + + + + + +
        +
      • +

        setOnFlowableAssembly

        +
        public static void setOnFlowableAssembly(@Nullable Function<? super Flowable,? extends Flowable> onFlowableAssembly)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        onFlowableAssembly - the hook function to set, null allowed
        +
        +
        • +
      + + + +
        +
      • +

        setOnMaybeAssembly

        +
        public static void setOnMaybeAssembly(@Nullable Function<? super Maybe,? extends Maybe> onMaybeAssembly)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        onMaybeAssembly - the hook function to set, null allowed
        +
        +
        • +
      + + + +
        +
      • +

        setOnConnectableFlowableAssembly

        +
        public static void setOnConnectableFlowableAssembly(@Nullable Function<? super ConnectableFlowable,? extends ConnectableFlowable> onConnectableFlowableAssembly)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        onConnectableFlowableAssembly - the hook function to set, null allowed
        +
        +
        • +
      + + + +
        +
      • +

        setOnFlowableSubscribe

        +
        public static void setOnFlowableSubscribe(@Nullable BiFunction<? super Flowable,? super Subscriber,? extends Subscriber> onFlowableSubscribe)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        onFlowableSubscribe - the hook function to set, null allowed
        +
        +
        • +
      + + + +
        +
      • +

        setOnMaybeSubscribe

        +
        public static void setOnMaybeSubscribe(@Nullable BiFunction<? super Maybe,MaybeObserver,? extends MaybeObserver> onMaybeSubscribe)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        onMaybeSubscribe - the hook function to set, null allowed
        +
        +
        • +
      + + + +
        +
      • +

        setOnObservableAssembly

        +
        public static void setOnObservableAssembly(@Nullable Function<? super Observable,? extends Observable> onObservableAssembly)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        onObservableAssembly - the hook function to set, null allowed
        +
        +
        • +
      + + + +
        +
      • +

        setOnConnectableObservableAssembly

        +
        public static void setOnConnectableObservableAssembly(@Nullable Function<? super ConnectableObservable,? extends ConnectableObservable> onConnectableObservableAssembly)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        onConnectableObservableAssembly - the hook function to set, null allowed
        +
        +
        • +
      + + + +
        +
      • +

        setOnObservableSubscribe

        +
        public static void setOnObservableSubscribe(@Nullable BiFunction<? super Observable,? super Observer,? extends Observer> onObservableSubscribe)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        onObservableSubscribe - the hook function to set, null allowed
        +
        +
        • +
      + + + +
        +
      • +

        setOnSingleAssembly

        +
        public static void setOnSingleAssembly(@Nullable Function<? super Single,? extends Single> onSingleAssembly)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        onSingleAssembly - the hook function to set, null allowed
        +
        +
        • +
      + + + +
        +
      • +

        setOnSingleSubscribe

        +
        public static void setOnSingleSubscribe(@Nullable BiFunction<? super Single,? super SingleObserver,? extends SingleObserver> onSingleSubscribe)
        +
        Sets the specific hook function.
        +
        +
        Parameters:
        +
        onSingleSubscribe - the hook function to set, null allowed
        +
        +
        • +
      + + + +
        +
      • +

        onSubscribe

        +
        @NonNull
+public static <T> @NonNull Subscriber<? super T> onSubscribe(@NonNull Flowable<T> source,
+        @NonNull Subscriber<? super T> subscriber)
        +
        Calls the associated hook function.
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        source - the hook's input value
        +
        subscriber - the subscriber
        +
        Returns:
        +
        the value returned by the hook
        +
        +
        • +
      + + + +
        +
      • +

        onSubscribe

        +
        @NonNull
+public static <T> @NonNull Observer<? super T> onSubscribe(@NonNull Observable<T> source,
+        @NonNull Observer<? super T> observer)
        +
        Calls the associated hook function.
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        source - the hook's input value
        +
        observer - the observer
        +
        Returns:
        +
        the value returned by the hook
        +
        +
        • +
      + + + +
        +
      • +

        onSubscribe

        +
        @NonNull
+public static <T> @NonNull SingleObserver<? super T> onSubscribe(@NonNull Single<T> source,
+        @NonNull SingleObserver<? super T> observer)
        +
        Calls the associated hook function.
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        source - the hook's input value
        +
        observer - the observer
        +
        Returns:
        +
        the value returned by the hook
        +
        +
        • +
      + + + + + + + +
        +
      • +

        onSubscribe

        +
        @NonNull
+public static <T> @NonNull MaybeObserver<? super T> onSubscribe(@NonNull Maybe<T> source,
+        @NonNull MaybeObserver<? super T> observer)
        +
        Calls the associated hook function.
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        source - the hook's input value
        +
        observer - the subscriber
        +
        Returns:
        +
        the value returned by the hook
        +
        +
        • +
      + + + +
        +
      • +

        onSubscribe

        +
        @NonNull
+public static <T> @NonNull Subscriber<? super T>[] onSubscribe(@NonNull ParallelFlowable<T> source,
+        @NonNull Subscriber<? super T>[] subscribers)
        +
        Calls the associated hook function.
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        source - the hook's input value
        +
        subscribers - the array of subscribers
        +
        Returns:
        +
        the value returned by the hook
        +
        +
        • +
      + + + +
        +
      • +

        onAssembly

        +
        @NonNull
+public static <T> @NonNull Maybe<T> onAssembly(@NonNull Maybe<T> source)
        +
        Calls the associated hook function.
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        source - the hook's input value
        +
        Returns:
        +
        the value returned by the hook
        +
        +
        • +
      + + + +
        +
      • +

        onAssembly

        +
        @NonNull
+public static <T> @NonNull Flowable<T> onAssembly(@NonNull Flowable<T> source)
        +
        Calls the associated hook function.
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        source - the hook's input value
        +
        Returns:
        +
        the value returned by the hook
        +
        +
        • +
      + + + + + + + +
        +
      • +

        onAssembly

        +
        @NonNull
+public static <T> @NonNull Observable<T> onAssembly(@NonNull Observable<T> source)
        +
        Calls the associated hook function.
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        source - the hook's input value
        +
        Returns:
        +
        the value returned by the hook
        +
        +
        • +
      + + + + + + + +
        +
      • +

        onAssembly

        +
        @NonNull
+public static <T> @NonNull Single<T> onAssembly(@NonNull Single<T> source)
        +
        Calls the associated hook function.
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        source - the hook's input value
        +
        Returns:
        +
        the value returned by the hook
        +
        +
        • +
      + + + +
        +
      • +

        onAssembly

        +
        @NonNull
+public static @NonNull Completable onAssembly(@NonNull Completable source)
        +
        Calls the associated hook function.
        +
        +
        Parameters:
        +
        source - the hook's input value
        +
        Returns:
        +
        the value returned by the hook
        +
        +
        • +
      + + + +
        +
      • +

        setOnParallelAssembly

        +
        public static void setOnParallelAssembly(@Nullable Function<? super ParallelFlowable,? extends ParallelFlowable> handler)
        +
        Sets the specific hook function. +

        History: 2.0.6 - experimental; 2.1 - beta

        +
        +
        Parameters:
        +
        handler - the hook function to set, null allowed
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        getOnParallelAssembly

        +
        @Nullable
+public static @Nullable Function<? super ParallelFlowable,? extends ParallelFlowable> getOnParallelAssembly()
        +
        Returns the current hook function. +

        History: 2.0.6 - experimental; 2.1 - beta

        +
        +
        Returns:
        +
        the hook function, may be null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        setOnParallelSubscribe

        +
        public static void setOnParallelSubscribe(@Nullable BiFunction<? super ParallelFlowable,? super Subscriber[],? extends Subscriber[]> handler)
        +
        Sets the specific hook function. +

        History: 3.0.11 - experimental

        +
        +
        Parameters:
        +
        handler - the hook function to set, null allowed
        +
        Since:
        +
        3.1.0
        +
        +
        • +
      + + + + + + + +
        +
      • +

        onAssembly

        +
        @NonNull
+public static <T> @NonNull ParallelFlowable<T> onAssembly(@NonNull ParallelFlowable<T> source)
        +
        Calls the associated hook function. +

        History: 2.0.6 - experimental; 2.1 - beta

        +
        +
        Type Parameters:
        +
        T - the value type of the source
        +
        Parameters:
        +
        source - the hook's input value
        +
        Returns:
        +
        the value returned by the hook
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        onBeforeBlocking

        +
        public static boolean onBeforeBlocking()
        +
        Called before an operator attempts a blocking operation + such as awaiting a condition or signal + and should return true to indicate the operator + should not block but throw an IllegalArgumentException. +

        History: 2.0.5 - experimental

        +
        +
        Returns:
        +
        true if the blocking should be prevented
        +
        Since:
        +
        2.1
        +
        See Also:
        +
        setFailOnNonBlockingScheduler(boolean)
        +
        +
        • +
      + + + +
        +
      • +

        setOnBeforeBlocking

        +
        public static void setOnBeforeBlocking(@Nullable BooleanSupplier handler)
        +
        Set the handler that is called when an operator attempts a blocking + await; the handler should return true to prevent the blocking + and to signal an IllegalStateException instead. +

        History: 2.0.5 - experimental

        +
        +
        Parameters:
        +
        handler - the handler to set, null resets to the default handler + that always returns false
        +
        Since:
        +
        2.1
        +
        See Also:
        +
        onBeforeBlocking()
        +
        +
        • +
      + + + +
        +
      • +

        getOnBeforeBlocking

        +
        @Nullable
+public static @Nullable BooleanSupplier getOnBeforeBlocking()
        +
        Returns the current blocking handler or null if no custom handler + is set. +

        History: 2.0.5 - experimental

        +
        +
        Returns:
        +
        the current blocking handler or null if not specified
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + +
        +
      • +

        createComputationScheduler

        +
        @NonNull
+public static @NonNull Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory)
        +
        Create an instance of the default Scheduler used for Schedulers.computation() + except using threadFactory for thread creation. +

        History: 2.0.5 - experimental

        +
        +
        Parameters:
        +
        threadFactory - thread factory to use for creating worker threads. Note that this takes precedence over any + system properties for configuring new thread creation. Cannot be null.
        +
        Returns:
        +
        the created Scheduler instance
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + +
        +
      • +

        createIoScheduler

        +
        @NonNull
+public static @NonNull Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory)
        +
        Create an instance of the default Scheduler used for Schedulers.io() + except using threadFactory for thread creation. +

        History: 2.0.5 - experimental

        +
        +
        Parameters:
        +
        threadFactory - thread factory to use for creating worker threads. Note that this takes precedence over any + system properties for configuring new thread creation. Cannot be null.
        +
        Returns:
        +
        the created Scheduler instance
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + +
        +
      • +

        createNewThreadScheduler

        +
        @NonNull
+public static @NonNull Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory)
        +
        Create an instance of the default Scheduler used for Schedulers.newThread() + except using threadFactory for thread creation. +

        History: 2.0.5 - experimental

        +
        +
        Parameters:
        +
        threadFactory - thread factory to use for creating worker threads. Note that this takes precedence over any + system properties for configuring new thread creation. Cannot be null.
        +
        Returns:
        +
        the created Scheduler instance
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + +
        +
      • +

        createSingleScheduler

        +
        @NonNull
+public static @NonNull Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory)
        +
        Create an instance of the default Scheduler used for Schedulers.single() + except using threadFactory for thread creation. +

        History: 2.0.5 - experimental

        +
        +
        Parameters:
        +
        threadFactory - thread factory to use for creating worker threads. Note that this takes precedence over any + system properties for configuring new thread creation. Cannot be null.
        +
        Returns:
        +
        the created Scheduler instance
        +
        Since:
        +
        2.1
        +
        +
        • +
      + + + +
        +
      • +

        createExecutorScheduler

        +
        @NonNull
+public static @NonNull Scheduler createExecutorScheduler(@NonNull Executor executor,
+        boolean interruptibleWorker,
+        boolean fair)
        +
        Create an instance of a Scheduler by wrapping an existing Executor. +

        + This method allows creating an Executor-backed Scheduler before the Schedulers class + would initialize the standard Schedulers.

        +
        +
        Parameters:
        +
        executor - the Executor to wrap and turn into a Scheduler.
        +
        interruptibleWorker - if true, the tasks submitted to the Scheduler.Worker will + be interrupted when the task is disposed.
        +
        fair - if true, tasks submitted to the Scheduler or Worker will be executed by the underlying Executor one after the other, still + in a FIFO and non-overlapping manner, but allows interleaving with other tasks submitted to the underlying Executor. + If false, the underlying FIFO scheme will execute as many tasks as it can before giving up the underlying Executor thread.
        +
        Returns:
        +
        the new Scheduler wrapping the Executor
        +
        Since:
        +
        3.1.0
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/package-frame.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/package-frame.html new file mode 100644 index 0000000000..fa2c7707c7 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/package-frame.html @@ -0,0 +1,19 @@ + + + + + +io.reactivex.rxjava3.plugins (RxJava Javadoc 3.1.8) + + + + +

io.reactivex.rxjava3.plugins

+
+

Classes

+ +
+ + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/package-summary.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/package-summary.html new file mode 100644 index 0000000000..9ebb85caf7 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/package-summary.html @@ -0,0 +1,152 @@ + + + + + +io.reactivex.rxjava3.plugins (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Package io.reactivex.rxjava3.plugins

+
+
Contains the central plugin handler RxJavaPlugins + class to hook into the lifecycle of the base reactive types and schedulers.
+
+

See: Description

+
+
+ + + + +

Package io.reactivex.rxjava3.plugins Description

+
Contains the central plugin handler RxJavaPlugins + class to hook into the lifecycle of the base reactive types and schedulers.
+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/package-tree.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/package-tree.html new file mode 100644 index 0000000000..6c64734ac9 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/plugins/package-tree.html @@ -0,0 +1,134 @@ + + + + + +io.reactivex.rxjava3.plugins Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For Package io.reactivex.rxjava3.plugins

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/AsyncProcessor.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/AsyncProcessor.html new file mode 100644 index 0000000000..1767d3670e --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/AsyncProcessor.html @@ -0,0 +1,621 @@ + + + + + +AsyncProcessor (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.processors
+

Class AsyncProcessor<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    All Implemented Interfaces:
    +
    FlowableSubscriber<T>, Processor<T,T>, Publisher<T>, Subscriber<T>
    +
    +
    +
    +
    public final class AsyncProcessor<T>
+extends FlowableProcessor<T>
    +
    Processor that emits the very last value followed by a completion event or the received error + to Subscribers. +

    + +

    + This processor does not have a public constructor by design; a new empty instance of this + AsyncProcessor can be created via the create() method. +

    + Since an AsyncProcessor is a Reactive Streams Processor type, + nulls are not allowed (Rule 2.13) + as parameters to onNext(Object) and onError(Throwable). Such calls will result in a + NullPointerException being thrown and the processor's state is not changed. +

    + AsyncProcessor is a Flowable as well as a FlowableProcessor and supports backpressure from the downstream but + its Subscriber-side consumes items in an unbounded manner. +

    + When this AsyncProcessor is terminated via onError(Throwable), the + last observed item (if any) is cleared and late Subscribers only receive + the onError event. +

    + The AsyncProcessor caches the latest item internally and it emits this item only when onComplete is called. + Therefore, it is not recommended to use this Processor with infinite or never-completing sources. +

    + Even though AsyncProcessor implements the Subscriber interface, calling + onSubscribe is not required (Rule 2.12) + if the processor is used as a standalone source. However, calling onSubscribe + after the AsyncProcessor reached its terminal state will result in the + given Subscription being canceled immediately. +

    + Calling onNext(Object), onError(Throwable) and onComplete() + is required to be serialized (called from the same thread or called non-overlappingly from different threads + through external means of serialization). The FlowableProcessor.toSerialized() method available to all FlowableProcessors + provides such serialization and also protects against reentrance (i.e., when a downstream Subscriber + consuming this processor also wants to call onNext(Object) on this processor recursively). + The implementation of onXXX methods are technically thread-safe but non-serialized calls + to them may lead to undefined state in the currently subscribed Subscribers. +

    + This AsyncProcessor supports the standard state-peeking methods hasComplete(), hasThrowable(), + getThrowable() and hasSubscribers() as well as means to read the very last observed value - + after this AsyncProcessor has been completed - in a non-blocking and thread-safe + manner via hasValue() or getValue(). +

    +
    Backpressure:
    +
    The AsyncProcessor honors the backpressure of the downstream Subscribers and won't emit + its single value to a particular Subscriber until that Subscriber has requested an item. + When the AsyncProcessor is subscribed to a Flowable, the processor consumes this + Flowable in an unbounded manner (requesting Long.MAX_VALUE) as only the very last upstream item is + retained by it. +
    +
    Scheduler:
    +
    AsyncProcessor does not operate by default on a particular Scheduler and + the Subscribers get notified on the thread where the terminating onError or onComplete + methods were invoked.
    +
    Error handling:
    +
    When the onError(Throwable) is called, the AsyncProcessor enters into a terminal state + and emits the same Throwable instance to the last set of Subscribers. During this emission, + if one or more Subscribers dispose their respective Subscriptions, the + Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) (multiple times if multiple Subscribers + cancel at once). + If there were no Subscribers subscribed to this AsyncProcessor when the onError() + was called, the global error handler is not invoked. +
    +
    +

    + Example usage: + 

    
+ AsyncProcessor<Object> processor = AsyncProcessor.create();
+ 
+ TestSubscriber<Object> ts1 = processor.test();
+
+ ts1.assertEmpty();
+
+ processor.onNext(1);
+
+ // AsyncProcessor only emits when onComplete was called.
+ ts1.assertEmpty();
+
+ processor.onNext(2);
+ processor.onComplete();
+
+ // onComplete triggers the emission of the last cached item and the onComplete event.
+ ts1.assertResult(2);
+
+ TestSubscriber<Object> ts2 = processor.test();
+
+ // late Subscribers receive the last cached item too
+ ts2.assertResult(2);
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull AsyncProcessor<T> create()
        +
        Creates a new AsyncProcessor.
        +
        +
        Type Parameters:
        +
        T - the value type to be received and emitted
        +
        Returns:
        +
        the new AsyncProcessor instance
        +
        +
        • +
      + + + +
        +
      • +

        onSubscribe

        +
        public void onSubscribe(@NonNull Subscription s)
        +
        Description copied from interface: FlowableSubscriber
        +
        Implementors of this method should make sure everything that needs + to be visible in Subscriber.onNext(Object) is established before + calling Subscription.request(long). In practice this means + no initialization should happen after the request() call and + additional behavior is thread safe in respect to onNext. + +
        +
        • +
      + + + + + +
        +
      • +

        onNext

        +
        public void onNext(@NonNull T t)
        +
        • +
      + + + + + + + +
        +
      • +

        onComplete

        +
        public void onComplete()
        +
        • +
      + + + +
        +
      • +

        hasSubscribers

        +
        @CheckReturnValue
+public boolean hasSubscribers()
        +
        Description copied from class: FlowableProcessor
        +
        Returns true if the FlowableProcessor has subscribers. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasSubscribers in class FlowableProcessor<T>
        +
        Returns:
        +
        true if the FlowableProcessor has subscribers
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        getThrowable

        +
        @Nullable
+ @CheckReturnValue
+public @Nullable Throwable getThrowable()
        +
        Description copied from class: FlowableProcessor
        +
        Returns the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor + hasn't terminated yet. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        getThrowable in class FlowableProcessor<T>
        +
        Returns:
        +
        the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor + hasn't terminated yet
        +
        +
        • +
      + + + +
        +
      • +

        subscribeActual

        +
        protected void subscribeActual(@NonNull Subscriber<? super T> s)
        +
        Description copied from class: Flowable
        +
        Operator implementations (both source and intermediate) should implement this method that + performs the necessary business logic and handles the incoming Subscribers. +

        There is no need to call any of the plugin hooks on the current Flowable instance or + the Subscriber; all hooks and basic safeguards have been + applied by Flowable.subscribe(Subscriber) before this method gets called.

        +
        +
        Specified by:
        +
        subscribeActual in class Flowable<T>
        +
        Parameters:
        +
        s - the incoming Subscriber, never null
        +
        +
        • +
      + + + +
        +
      • +

        hasValue

        +
        @CheckReturnValue
+public boolean hasValue()
        +
        Returns true if this processor has any value. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        true if this processor has any value
        +
        +
        • +
      + + + +
        +
      • +

        getValue

        +
        @Nullable
+ @CheckReturnValue
+public T getValue()
        +
        Returns a single value this processor currently has or null if no such value exists. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        a single value this processor currently has or null if no such value exists
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/BehaviorProcessor.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/BehaviorProcessor.html new file mode 100644 index 0000000000..491522ce37 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/BehaviorProcessor.html @@ -0,0 +1,729 @@ + + + + + +BehaviorProcessor (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.processors
+

Class BehaviorProcessor<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the type of item expected to be observed and emitted by the Processor
    +
    +
    +
    All Implemented Interfaces:
    +
    FlowableSubscriber<T>, Processor<T,T>, Publisher<T>, Subscriber<T>
    +
    +
    +
    +
    public final class BehaviorProcessor<T>
+extends FlowableProcessor<T>
    +
    Processor that emits the most recent item it has observed and all subsequent observed items to each subscribed + Subscriber. +

    + +

    + This processor does not have a public constructor by design; a new empty instance of this + BehaviorProcessor can be created via the create() method and + a new non-empty instance can be created via createDefault(Object) (named as such to avoid + overload resolution conflict with Flowable.create that creates a Flowable, not a BehaviorProcessor). +

    + In accordance with the Reactive Streams specification (Rule 2.13) + nulls are not allowed as default initial values in createDefault(Object) or as parameters to onNext(Object) and + onError(Throwable). +

    + When this BehaviorProcessor is terminated via onError(Throwable) or onComplete(), the + last observed item (if any) is cleared and late Subscribers only receive + the respective terminal event. +

    + The BehaviorProcessor does not support clearing its cached value (to appear empty again), however, the + effect can be achieved by using a special item and making sure Subscribers subscribe through a + filter whose predicate filters out this special item: + 

    
+ BehaviorProcessor<Integer> processor = BehaviorProcessor.create();
+
+ final Integer EMPTY = Integer.MIN_VALUE;
+
+ Flowable<Integer> flowable = processor.filter(v -> v != EMPTY);
+
+ TestSubscriber<Integer> ts1 = flowable.test();
+
+ processor.onNext(1);
+ // this will "clear" the cache
+ processor.onNext(EMPTY);
+ 
+ TestSubscriber<Integer> ts2 = flowable.test();
+ 
+ processor.onNext(2);
+ processor.onComplete();
+ 
+ // ts1 received both non-empty items
+ ts1.assertResult(1, 2);
+ 
+ // ts2 received only 2 even though the current item was EMPTY
+ // when it got subscribed
+ ts2.assertResult(2);
+ 
+ // Subscribers coming after the processor was terminated receive
+ // no items and only the onComplete event in this case.
+ flowable.test().assertResult();
+
    +

    + Even though BehaviorProcessor implements the Subscriber interface, calling + onSubscribe is not required (Rule 2.12) + if the processor is used as a standalone source. However, calling onSubscribe + after the BehaviorProcessor reached its terminal state will result in the + given Subscription being cancelled immediately. +

    + Calling onNext(Object), offer(Object), onError(Throwable) and onComplete() + is required to be serialized (called from the same thread or called non-overlappingly from different threads + through external means of serialization). The FlowableProcessor.toSerialized() method available to all FlowableProcessors + provides such serialization and also protects against reentrance (i.e., when a downstream Subscriber + consuming this processor also wants to call onNext(Object) on this processor recursively). + Note that serializing over offer(Object) is not supported through toSerialized() because it is a method + available on the PublishProcessor and BehaviorProcessor classes only. +

    + This BehaviorProcessor supports the standard state-peeking methods hasComplete(), hasThrowable(), + getThrowable() and hasSubscribers() as well as means to read the latest observed value + in a non-blocking and thread-safe manner via hasValue() or getValue(). +

    + Note that this processor signals MissingBackpressureException if a particular Subscriber is not + ready to receive onNext events. To avoid this exception being signaled, use offer(Object) to only + try to emit an item when all Subscribers have requested item(s). +

    +
    Backpressure:
    +
    The BehaviorProcessor does not coordinate requests of its downstream Subscribers and + expects each individual Subscriber is ready to receive onNext items when onNext(Object) + is called. If a Subscriber is not ready, a MissingBackpressureException is signalled to it. + To avoid overflowing the current Subscribers, the conditional offer(Object) method is available + that returns true if any of the Subscribers is not ready to receive onNext events. If + there are no Subscribers to the processor, offer() always succeeds. + If the BehaviorProcessor is (optionally) subscribed to another Publisher, this upstream + Publisher is consumed in an unbounded fashion (requesting Long.MAX_VALUE).
    +
    Scheduler:
    +
    BehaviorProcessor does not operate by default on a particular Scheduler and + the Subscribers get notified on the thread the respective onXXX methods were invoked.
    +
    Error handling:
    +
    When the onError(Throwable) is called, the BehaviorProcessor enters into a terminal state + and emits the same Throwable instance to the last set of Subscribers. During this emission, + if one or more Subscribers cancel their respective Subscriptions, the + Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) (multiple times if multiple Subscribers + cancel at once). + If there were no Subscribers subscribed to this BehaviorProcessor when the onError() + was called, the global error handler is not invoked. +
    +
    +

    + Example usage: + 

     
+
+  // subscriber will receive all events.
+  BehaviorProcessor<Object> processor = BehaviorProcessor.create("default");
+  processor.subscribe(subscriber);
+  processor.onNext("one");
+  processor.onNext("two");
+  processor.onNext("three");
+
+  // subscriber will receive the "one", "two" and "three" events, but not "zero"
+  BehaviorProcessor<Object> processor = BehaviorProcessor.create("default");
+  processor.onNext("zero");
+  processor.onNext("one");
+  processor.subscribe(subscriber);
+  processor.onNext("two");
+  processor.onNext("three");
+
+  // subscriber will receive only onComplete
+  BehaviorProcessor<Object> processor = BehaviorProcessor.create("default");
+  processor.onNext("zero");
+  processor.onNext("one");
+  processor.onComplete();
+  processor.subscribe(subscriber);
+
+  // subscriber will receive only onError
+  BehaviorProcessor<Object> processor = BehaviorProcessor.create("default");
+  processor.onNext("zero");
+  processor.onNext("one");
+  processor.onError(new RuntimeException("error"));
+  processor.subscribe(subscriber);
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + + + + + + + + + +
        +
      • +

        subscribeActual

        +
        protected void subscribeActual(@NonNull Subscriber<? super T> s)
        +
        Description copied from class: Flowable
        +
        Operator implementations (both source and intermediate) should implement this method that + performs the necessary business logic and handles the incoming Subscribers. +

        There is no need to call any of the plugin hooks on the current Flowable instance or + the Subscriber; all hooks and basic safeguards have been + applied by Flowable.subscribe(Subscriber) before this method gets called.

        +
        +
        Specified by:
        +
        subscribeActual in class Flowable<T>
        +
        Parameters:
        +
        s - the incoming Subscriber, never null
        +
        +
        • +
      + + + +
        +
      • +

        onSubscribe

        +
        public void onSubscribe(@NonNull Subscription s)
        +
        Description copied from interface: FlowableSubscriber
        +
        Implementors of this method should make sure everything that needs + to be visible in Subscriber.onNext(Object) is established before + calling Subscription.request(long). In practice this means + no initialization should happen after the request() call and + additional behavior is thread safe in respect to onNext. + +
        +
        • +
      + + + + + +
        +
      • +

        onNext

        +
        public void onNext(@NonNull T t)
        +
        • +
      + + + + + + + +
        +
      • +

        onComplete

        +
        public void onComplete()
        +
        • +
      + + + + + +
        +
      • +

        offer

        +
        @CheckReturnValue
+public boolean offer(@NonNull T t)
        +
        Tries to emit the item to all currently subscribed Subscribers if all of them + has requested some value, returns false otherwise. +

        + This method should be called in a sequential manner just like the onXXX methods + of this BehaviorProcessor. +

        History: 2.0.8 - experimental

        +
        +
        Parameters:
        +
        t - the item to emit, not null
        +
        Returns:
        +
        true if the item was emitted to all Subscribers
        +
        Throws:
        +
        NullPointerException - if t is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        hasSubscribers

        +
        @CheckReturnValue
+public boolean hasSubscribers()
        +
        Description copied from class: FlowableProcessor
        +
        Returns true if the FlowableProcessor has subscribers. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasSubscribers in class FlowableProcessor<T>
        +
        Returns:
        +
        true if the FlowableProcessor has subscribers
        +
        +
        • +
      + + + +
        +
      • +

        getThrowable

        +
        @Nullable
+ @CheckReturnValue
+public @Nullable Throwable getThrowable()
        +
        Description copied from class: FlowableProcessor
        +
        Returns the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor + hasn't terminated yet. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        getThrowable in class FlowableProcessor<T>
        +
        Returns:
        +
        the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor + hasn't terminated yet
        +
        +
        • +
      + + + +
        +
      • +

        getValue

        +
        @Nullable
+ @CheckReturnValue
+public T getValue()
        +
        Returns a single value the BehaviorProcessor currently has or null if no such value exists. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        a single value the BehaviorProcessor currently has or null if no such value exists
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        hasValue

        +
        @CheckReturnValue
+public boolean hasValue()
        +
        Returns true if the BehaviorProcessor has any value. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        true if the BehaviorProcessor has any value
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/FlowableProcessor.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/FlowableProcessor.html new file mode 100644 index 0000000000..accc29577a --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/FlowableProcessor.html @@ -0,0 +1,427 @@ + + + + + +FlowableProcessor (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.processors
+

Class FlowableProcessor<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        FlowableProcessor

        +
        public FlowableProcessor()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        hasSubscribers

        +
        @CheckReturnValue
+public abstract boolean hasSubscribers()
        +
        Returns true if the FlowableProcessor has subscribers. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        true if the FlowableProcessor has subscribers
        +
        +
        • +
      + + + +
        +
      • +

        hasThrowable

        +
        @CheckReturnValue
+public abstract boolean hasThrowable()
        +
        Returns true if the FlowableProcessor has reached a terminal state through an error event. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        true if the FlowableProcessor has reached a terminal state through an error event
        +
        See Also:
        +
        getThrowable(), +hasComplete()
        +
        +
        • +
      + + + +
        +
      • +

        hasComplete

        +
        @CheckReturnValue
+public abstract boolean hasComplete()
        +
        Returns true if the FlowableProcessor has reached a terminal state through a complete event. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        true if the FlowableProcessor has reached a terminal state through a complete event
        +
        See Also:
        +
        hasThrowable()
        +
        +
        • +
      + + + +
        +
      • +

        getThrowable

        +
        @Nullable
+ @CheckReturnValue
+public abstract @Nullable Throwable getThrowable()
        +
        Returns the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor + hasn't terminated yet. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor + hasn't terminated yet
        +
        +
        • +
      + + + +
        +
      • +

        toSerialized

        +
        @NonNull
+ @CheckReturnValue
+public final @NonNull FlowableProcessor<T> toSerialized()
        +
        Wraps this FlowableProcessor and serializes the calls to the onSubscribe, onNext, onError and + onComplete methods, making them thread-safe. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        the wrapped and serialized FlowableProcessor
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/MulticastProcessor.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/MulticastProcessor.html new file mode 100644 index 0000000000..71cf448db8 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/MulticastProcessor.html @@ -0,0 +1,757 @@ + + + + + +MulticastProcessor (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.processors
+

Class MulticastProcessor<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the input and output value type
    +
    +
    +
    All Implemented Interfaces:
    +
    FlowableSubscriber<T>, Processor<T,T>, Publisher<T>, Subscriber<T>
    +
    +
    +
    +
    @BackpressureSupport(value=FULL)
+ @SchedulerSupport(value="none")
+public final class MulticastProcessor<T>
+extends FlowableProcessor<T>
    +
    A FlowableProcessor implementation that coordinates downstream requests through + a front-buffer and stable-prefetching, optionally canceling the upstream if all + subscribers have cancelled. +

    + +

    + This processor does not have a public constructor by design; a new empty instance of this + MulticastProcessor can be created via the following create methods that + allow configuring it: +

      +
    • create(): create an empty MulticastProcessor with + Flowable.bufferSize() prefetch amount + and no reference counting behavior.
      • +
    • create(int): create an empty MulticastProcessor with + the given prefetch amount and no reference counting behavior.
      • +
    • create(boolean): create an empty MulticastProcessor with + Flowable.bufferSize() prefetch amount + and an optional reference counting behavior.
      • +
    • create(int, boolean): create an empty MulticastProcessor with + the given prefetch amount and an optional reference counting behavior.
      • +
    +

    + When the reference counting behavior is enabled, the MulticastProcessor cancels its + upstream when all Subscribers have cancelled. Late Subscribers will then be + immediately completed. +

    + Because MulticastProcessor implements the Subscriber interface, calling + onSubscribe is mandatory (Rule 2.12). + If MulticastProcessor should run standalone, i.e., without subscribing the MulticastProcessor to another Publisher, + use start() or startUnbounded() methods to initialize the internal buffer. + Failing to do so will lead to a NullPointerException at runtime. +

    + Use offer(Object) to try and offer/emit items but don't fail if the + internal buffer is full. +

    + A MulticastProcessor is a Processor type in the Reactive Streams specification, + nulls are not allowed (Rule 2.13) as + parameters to onSubscribe(Subscription), offer(Object), onNext(Object) and onError(Throwable). + Such calls will result in a NullPointerException being thrown and the processor's state is not changed. +

    + Since a MulticastProcessor is a Flowable, it supports backpressure. + The backpressure from the currently subscribed Subscribers are coordinated by emitting upstream + items only if all of those Subscribers have requested at least one item. This behavior + is also called lockstep-mode because even if some Subscribers can take any number + of items, other Subscribers requesting less or infrequently will slow down the overall + throughput of the flow. +

    + Calling onNext(Object), offer(Object), onError(Throwable) and onComplete() + is required to be serialized (called from the same thread or called non-overlappingly from different threads + through external means of serialization). The FlowableProcessor.toSerialized() method available to all FlowableProcessors + provides such serialization and also protects against reentrance (i.e., when a downstream Subscriber + consuming this processor also wants to call onNext(Object) on this processor recursively). +

    + This MulticastProcessor supports the standard state-peeking methods hasComplete(), hasThrowable(), + getThrowable() and hasSubscribers(). This processor doesn't allow peeking into its buffer. +

    + When this MulticastProcessor is terminated via onError(Throwable) or onComplete(), + all previously signaled but not yet consumed items will be still available to Subscribers and the respective + terminal even is only emitted when all previous items have been successfully delivered to Subscribers. + If there are no Subscribers, the remaining items will be buffered indefinitely. +

    + The MulticastProcessor does not support clearing its cached events (to appear empty again). +

    +
    Backpressure:
    +
    The backpressure from the currently subscribed Subscribers are coordinated by emitting upstream + items only if all of those Subscribers have requested at least one item. This behavior + is also called lockstep-mode because even if some Subscribers can take any number + of items, other Subscribers requesting less or infrequently will slow down the overall + throughput of the flow.
    +
    Scheduler:
    +
    MulticastProcessor does not operate by default on a particular Scheduler and + the Subscribers get notified on an arbitrary thread in a serialized fashion.
    +
    +

    + Example: + 

    
+    MulticastProcessor<Integer> mp = Flowable.range(1, 10)
+    .subscribeWith(MulticastProcessor.create());
+
+    mp.test().assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+
+    // --------------------
+
+    MulticastProcessor<Integer> mp2 = MulticastProcessor.create(4);
+    mp2.start();
+
+    assertTrue(mp2.offer(1));
+    assertTrue(mp2.offer(2));
+    assertTrue(mp2.offer(3));
+    assertTrue(mp2.offer(4));
+
+    assertFalse(mp2.offer(5));
+
+    mp2.onComplete();
+
+    mp2.test().assertResult(1, 2, 3, 4);
+
    +

    History: 2.1.14 - experimental

    +
    +
    Since:
    +
    2.2
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull MulticastProcessor<T> create()
        +
        Constructs a fresh instance with the default Flowable.bufferSize() prefetch + amount and no refCount-behavior.
        +
        +
        Type Parameters:
        +
        T - the input and output value type
        +
        Returns:
        +
        the new MulticastProcessor instance
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull MulticastProcessor<T> create(boolean refCount)
        +
        Constructs a fresh instance with the default Flowable.bufferSize() prefetch + amount and the optional refCount-behavior.
        +
        +
        Type Parameters:
        +
        T - the input and output value type
        +
        Parameters:
        +
        refCount - if true and if all Subscribers have canceled, the upstream + is cancelled
        +
        Returns:
        +
        the new MulticastProcessor instance
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull MulticastProcessor<T> create(int bufferSize)
        +
        Constructs a fresh instance with the given prefetch amount and no refCount behavior.
        +
        +
        Type Parameters:
        +
        T - the input and output value type
        +
        Parameters:
        +
        bufferSize - the prefetch amount
        +
        Returns:
        +
        the new MulticastProcessor instance
        +
        Throws:
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull MulticastProcessor<T> create(int bufferSize,
+        boolean refCount)
        +
        Constructs a fresh instance with the given prefetch amount and the optional + refCount-behavior.
        +
        +
        Type Parameters:
        +
        T - the input and output value type
        +
        Parameters:
        +
        bufferSize - the prefetch amount
        +
        refCount - if true and if all Subscribers have canceled, the upstream + is cancelled
        +
        Returns:
        +
        the new MulticastProcessor instance
        +
        Throws:
        +
        IllegalArgumentException - if bufferSize is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        start

        +
        public void start()
        +
        Initializes this Processor by setting an upstream Subscription that + ignores request amounts, uses a fixed buffer + and allows using the onXXX and offer methods + afterwards.
        +
        • +
      + + + +
        +
      • +

        startUnbounded

        +
        public void startUnbounded()
        +
        Initializes this Processor by setting an upstream Subscription that + ignores request amounts, uses an unbounded buffer + and allows using the onXXX and offer methods + afterwards.
        +
        • +
      + + + +
        +
      • +

        onSubscribe

        +
        public void onSubscribe(@NonNull Subscription s)
        +
        Description copied from interface: FlowableSubscriber
        +
        Implementors of this method should make sure everything that needs + to be visible in Subscriber.onNext(Object) is established before + calling Subscription.request(long). In practice this means + no initialization should happen after the request() call and + additional behavior is thread safe in respect to onNext. + +
        +
        • +
      + + + + + +
        +
      • +

        onNext

        +
        public void onNext(@NonNull T t)
        +
        • +
      + + + + + +
        +
      • +

        offer

        +
        @CheckReturnValue
+public boolean offer(@NonNull T t)
        +
        Tries to offer an item into the internal queue and returns false + if the queue is full.
        +
        +
        Parameters:
        +
        t - the item to offer, not null
        +
        Returns:
        +
        true if successful, false if the queue is full
        +
        Throws:
        +
        NullPointerException - if t is null
        +
        IllegalStateException - if the processor is in fusion mode
        +
        +
        • +
      + + + + + + + +
        +
      • +

        onComplete

        +
        public void onComplete()
        +
        • +
      + + + +
        +
      • +

        hasSubscribers

        +
        @CheckReturnValue
+public boolean hasSubscribers()
        +
        Description copied from class: FlowableProcessor
        +
        Returns true if the FlowableProcessor has subscribers. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasSubscribers in class FlowableProcessor<T>
        +
        Returns:
        +
        true if the FlowableProcessor has subscribers
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        getThrowable

        +
        @CheckReturnValue
+public Throwable getThrowable()
        +
        Description copied from class: FlowableProcessor
        +
        Returns the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor + hasn't terminated yet. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        getThrowable in class FlowableProcessor<T>
        +
        Returns:
        +
        the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor + hasn't terminated yet
        +
        +
        • +
      + + + +
        +
      • +

        subscribeActual

        +
        protected void subscribeActual(@NonNull Subscriber<? super T> s)
        +
        Description copied from class: Flowable
        +
        Operator implementations (both source and intermediate) should implement this method that + performs the necessary business logic and handles the incoming Subscribers. +

        There is no need to call any of the plugin hooks on the current Flowable instance or + the Subscriber; all hooks and basic safeguards have been + applied by Flowable.subscribe(Subscriber) before this method gets called.

        +
        +
        Specified by:
        +
        subscribeActual in class Flowable<T>
        +
        Parameters:
        +
        s - the incoming Subscriber, never null
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/PublishProcessor.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/PublishProcessor.html new file mode 100644 index 0000000000..ed166eadd1 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/PublishProcessor.html @@ -0,0 +1,606 @@ + + + + + +PublishProcessor (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.processors
+

Class PublishProcessor<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type multicasted to Subscribers.
    +
    +
    +
    All Implemented Interfaces:
    +
    FlowableSubscriber<T>, Processor<T,T>, Publisher<T>, Subscriber<T>
    +
    +
    +
    +
    public final class PublishProcessor<T>
+extends FlowableProcessor<T>
    +
    Processor that multicasts all subsequently observed items to its current Subscribers. + +

    + +

    + This processor does not have a public constructor by design; a new empty instance of this + PublishProcessor can be created via the create() method. +

    + Since a PublishProcessor is a Reactive Streams Processor type, + nulls are not allowed (Rule 2.13) as + parameters to onNext(Object) and onError(Throwable). Such calls will result in a + NullPointerException being thrown and the processor's state is not changed. +

    + PublishProcessor is a Flowable as well as a FlowableProcessor, + however, it does not coordinate backpressure between different subscribers and between an + upstream source and a subscriber. If an upstream item is received via onNext(Object), if + a subscriber is not ready to receive an item, that subscriber is terminated via a MissingBackpressureException. + To avoid this case, use offer(Object) and retry sometime later if it returned false. + The PublishProcessor's Subscriber-side consumes items in an unbounded manner. +

    + For a multicasting processor type that also coordinates between the downstream Subscribers and the upstream + source as well, consider using MulticastProcessor. +

    + When this PublishProcessor is terminated via onError(Throwable) or onComplete(), + late Subscribers only receive the respective terminal event. +

    + Unlike a BehaviorProcessor, a PublishProcessor doesn't retain/cache items, therefore, a new + Subscriber won't receive any past items. +

    + Even though PublishProcessor implements the Subscriber interface, calling + onSubscribe is not required (Rule 2.12) + if the processor is used as a standalone source. However, calling onSubscribe + after the PublishProcessor reached its terminal state will result in the + given Subscription being canceled immediately. +

    + Calling onNext(Object), offer(Object), onError(Throwable) and onComplete() + is required to be serialized (called from the same thread or called non-overlappingly from different threads + through external means of serialization). The FlowableProcessor.toSerialized() method available to all FlowableProcessors + provides such serialization and also protects against reentrance (i.e., when a downstream Subscriber + consuming this processor also wants to call onNext(Object) on this processor recursively). + Note that serializing over offer(Object) is not supported through toSerialized() because it is a method + available on the PublishProcessor and BehaviorProcessor classes only. +

    + This PublishProcessor supports the standard state-peeking methods hasComplete(), hasThrowable(), + getThrowable() and hasSubscribers(). +

    +
    Backpressure:
    +
    The processor does not coordinate backpressure for its subscribers and implements a weaker onSubscribe which + calls requests Long.MAX_VALUE from the incoming Subscriptions. This makes it possible to subscribe the PublishProcessor + to multiple sources (note on serialization though) unlike the standard Subscriber contract. Child subscribers, however, are not overflown but receive an + IllegalStateException in case their requested amount is zero.
    +
    Scheduler:
    +
    PublishProcessor does not operate by default on a particular Scheduler and + the Subscribers get notified on the thread the respective onXXX methods were invoked.
    +
    Error handling:
    +
    When the onError(Throwable) is called, the PublishProcessor enters into a terminal state + and emits the same Throwable instance to the last set of Subscribers. During this emission, + if one or more Subscribers cancel their respective Subscriptions, the + Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) (multiple times if multiple Subscribers + cancel at once). + If there were no Subscribers subscribed to this PublishProcessor when the onError() + was called, the global error handler is not invoked. +
    +
    + + Example usage: + 
     
+
+  PublishProcessor<Object> processor = PublishProcessor.create();
+  // subscriber1 will receive all onNext and onComplete events
+  processor.subscribe(subscriber1);
+  processor.onNext("one");
+  processor.onNext("two");
+  // subscriber2 will only receive "three" and onComplete
+  processor.subscribe(subscriber2);
+  processor.onNext("three");
+  processor.onComplete();
+
+
    +
    +
    See Also:
    +
    MulticastProcessor
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        subscribeActual

        +
        protected void subscribeActual(@NonNull Subscriber<? super T> t)
        +
        Description copied from class: Flowable
        +
        Operator implementations (both source and intermediate) should implement this method that + performs the necessary business logic and handles the incoming Subscribers. +

        There is no need to call any of the plugin hooks on the current Flowable instance or + the Subscriber; all hooks and basic safeguards have been + applied by Flowable.subscribe(Subscriber) before this method gets called.

        +
        +
        Specified by:
        +
        subscribeActual in class Flowable<T>
        +
        Parameters:
        +
        t - the incoming Subscriber, never null
        +
        +
        • +
      + + + +
        +
      • +

        onSubscribe

        +
        public void onSubscribe(@NonNull Subscription s)
        +
        Description copied from interface: FlowableSubscriber
        +
        Implementors of this method should make sure everything that needs + to be visible in Subscriber.onNext(Object) is established before + calling Subscription.request(long). In practice this means + no initialization should happen after the request() call and + additional behavior is thread safe in respect to onNext. + +
        +
        • +
      + + + + + +
        +
      • +

        onNext

        +
        public void onNext(@NonNull T t)
        +
        • +
      + + + + + + + +
        +
      • +

        onComplete

        +
        public void onComplete()
        +
        • +
      + + + + + +
        +
      • +

        offer

        +
        @CheckReturnValue
+public boolean offer(@NonNull T t)
        +
        Tries to emit the item to all currently subscribed Subscribers if all of them + has requested some value, returns false otherwise. +

        + This method should be called in a sequential manner just like the onXXX methods + of this PublishProcessor. +

        History: 2.0.8 - experimental

        +
        +
        Parameters:
        +
        t - the item to emit, not null
        +
        Returns:
        +
        true if the item was emitted to all Subscribers
        +
        Throws:
        +
        NullPointerException - if t is null
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        hasSubscribers

        +
        @CheckReturnValue
+public boolean hasSubscribers()
        +
        Description copied from class: FlowableProcessor
        +
        Returns true if the FlowableProcessor has subscribers. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasSubscribers in class FlowableProcessor<T>
        +
        Returns:
        +
        true if the FlowableProcessor has subscribers
        +
        +
        • +
      + + + +
        +
      • +

        getThrowable

        +
        @Nullable
+ @CheckReturnValue
+public @Nullable Throwable getThrowable()
        +
        Description copied from class: FlowableProcessor
        +
        Returns the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor + hasn't terminated yet. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        getThrowable in class FlowableProcessor<T>
        +
        Returns:
        +
        the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor + hasn't terminated yet
        +
        +
        • +
      + + + + + + + + +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/ReplayProcessor.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/ReplayProcessor.html new file mode 100644 index 0000000000..91007f33f6 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/ReplayProcessor.html @@ -0,0 +1,912 @@ + + + + + +ReplayProcessor (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.processors
+

Class ReplayProcessor<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    All Implemented Interfaces:
    +
    FlowableSubscriber<T>, Processor<T,T>, Publisher<T>, Subscriber<T>
    +
    +
    +
    +
    public final class ReplayProcessor<T>
+extends FlowableProcessor<T>
    +
    Replays events to Subscribers. +

    + The ReplayProcessor supports the following item retention strategies: +

    +

    + The ReplayProcessor can be created in bounded and unbounded mode. It can be bounded by + size (maximum number of elements retained at most) and/or time (maximum age of elements replayed). +

    + Since a ReplayProcessor is a Reactive Streams Processor, + nulls are not allowed (Rule 2.13) as + parameters to onNext(Object) and onError(Throwable). Such calls will result in a + NullPointerException being thrown and the processor's state is not changed. +

    + This ReplayProcessor respects the individual backpressure behavior of its Subscribers but + does not coordinate their request amounts towards the upstream (because there might not be any) and + consumes the upstream in an unbounded manner (requesting Long.MAX_VALUE). + Note that Subscribers receive a continuous sequence of values after they subscribed even + if an individual item gets delayed due to backpressure. + Due to concurrency requirements, a size-bounded ReplayProcessor may hold strong references to more source + emissions than specified. +

    + When this ReplayProcessor is terminated via onError(Throwable) or onComplete(), + late Subscribers will receive the retained/cached items first (if any) followed by the respective + terminal event. If the ReplayProcessor has a time-bound, the age of the retained/cached items are still considered + when replaying and thus it may result in no items being emitted before the terminal event. +

    + Once an Subscriber has subscribed, it will receive items continuously from that point on. Bounds only affect how + many past items a new Subscriber will receive before it catches up with the live event feed. +

    + Even though ReplayProcessor implements the Subscriber interface, calling + onSubscribe is not required (Rule 2.12) + if the processor is used as a standalone source. However, calling onSubscribe + after the ReplayProcessor reached its terminal state will result in the + given Subscription being canceled immediately. +

    + Calling onNext(Object), onError(Throwable) and onComplete() + is required to be serialized (called from the same thread or called non-overlappingly from different threads + through external means of serialization). The FlowableProcessor.toSerialized() method available to all FlowableProcessors + provides such serialization and also protects against reentrance (i.e., when a downstream Subscriber + consuming this processor also wants to call onNext(Object) on this processor recursively). +

    + This ReplayProcessor supports the standard state-peeking methods hasComplete(), hasThrowable(), + getThrowable() and hasSubscribers() as well as means to read the retained/cached items + in a non-blocking and thread-safe manner via hasValue(), getValue(), + getValues() or getValues(Object[]). +

    + Note that due to concurrency requirements, a size- and time-bounded ReplayProcessor may hold strong references to more + source emissions than specified while it isn't terminated yet. Use the cleanupBuffer() to allow + such inaccessible items to be cleaned up by GC once no consumer references them anymore. +

    +
    Backpressure:
    +
    This ReplayProcessor respects the individual backpressure behavior of its Subscribers but + does not coordinate their request amounts towards the upstream (because there might not be any) and + consumes the upstream in an unbounded manner (requesting Long.MAX_VALUE). + Note that Subscribers receive a continuous sequence of values after they subscribed even + if an individual item gets delayed due to backpressure.
    +
    Scheduler:
    +
    ReplayProcessor does not operate by default on a particular Scheduler and + the Subscribers get notified on the thread the respective onXXX methods were invoked. + Time-bound ReplayProcessors use the given Scheduler in their create methods + as time source to timestamp of items received for the age checks.
    +
    Error handling:
    +
    When the onError(Throwable) is called, the ReplayProcessor enters into a terminal state + and emits the same Throwable instance to the last set of Subscribers. During this emission, + if one or more Subscribers cancel their respective Subscriptions, the + Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) (multiple times if multiple Subscribers + cancel at once). + If there were no Subscribers subscribed to this ReplayProcessor when the onError() + was called, the global error handler is not invoked. +
    +
    +

    + Example usage: + 

     
+
+  ReplayProcessor<Object> processor = new ReplayProcessor<T>();
+  processor.onNext("one");
+  processor.onNext("two");
+  processor.onNext("three");
+  processor.onComplete();
+
+  // both of the following will get the onNext/onComplete calls from above
+  processor.subscribe(subscriber1);
+  processor.subscribe(subscriber2);
+
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull ReplayProcessor<T> create()
        +
        Creates an unbounded ReplayProcessor. +

        + The internal buffer is backed by an ArrayList and starts with an initial capacity of 16. Once the + number of items reaches this capacity, it will grow as necessary (usually by 50%). However, as the + number of items grows, this causes frequent array reallocation and copying, and may hurt performance + and latency. This can be avoided with the create(int) overload which takes an initial capacity + parameter and can be tuned to reduce the array reallocation frequency as needed.

        +
        +
        Type Parameters:
        +
        T - the type of items observed and emitted by the ReplayProcessor
        +
        Returns:
        +
        the created ReplayProcessor
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull ReplayProcessor<T> create(int capacityHint)
        +
        Creates an unbounded ReplayProcessor with the specified initial buffer capacity. +

        + Use this method to avoid excessive array reallocation while the internal buffer grows to accommodate new + items. For example, if you know that the buffer will hold 32k items, you can ask the + ReplayProcessor to preallocate its internal array with a capacity to hold that many items. Once + the items start to arrive, the internal array won't need to grow, creating less garbage and no overhead + due to frequent array-copying.

        +
        +
        Type Parameters:
        +
        T - the type of items observed and emitted by this type of processor
        +
        Parameters:
        +
        capacityHint - the initial buffer capacity
        +
        Returns:
        +
        the created processor
        +
        Throws:
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        createWithSize

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull ReplayProcessor<T> createWithSize(int maxSize)
        +
        Creates a size-bounded ReplayProcessor. +

        + In this setting, the ReplayProcessor holds at most size items in its internal buffer and + discards the oldest item. +

        + When Subscribers subscribe to a terminated ReplayProcessor, they are guaranteed to see at most + size onNext events followed by a termination event. +

        + If a Subscriber subscribes while the ReplayProcessor is active, it will observe all items in the + buffer at that point in time and each item observed afterwards, even if the buffer evicts items due to + the size constraint in the mean time. In other words, once a Subscriber subscribes, it will receive items + without gaps in the sequence.

        +
        +
        Type Parameters:
        +
        T - the type of items observed and emitted by this type of processor
        +
        Parameters:
        +
        maxSize - the maximum number of buffered items
        +
        Returns:
        +
        the created processor
        +
        Throws:
        +
        IllegalArgumentException - if maxSize is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        createWithTime

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull ReplayProcessor<T> createWithTime(long maxAge,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Creates a time-bounded ReplayProcessor. +

        + In this setting, the ReplayProcessor internally tags each observed item with a timestamp value + supplied by the Scheduler and keeps only those whose age is less than the supplied time value + converted to milliseconds. For example, an item arrives at T=0 and the max age is set to 5; at T>=5 + this first item is then evicted by any subsequent item or termination event, leaving the buffer empty. +

        + Once the processor is terminated, Subscribers subscribing to it will receive items that remained in the + buffer after the terminal event, regardless of their age. +

        + If a Subscriber subscribes while the ReplayProcessor is active, it will observe only those items + from within the buffer that have an age less than the specified time, and each item observed thereafter, + even if the buffer evicts items due to the time constraint in the mean time. In other words, once a + Subscriber subscribes, it observes items without gaps in the sequence except for any outdated items at the + beginning of the sequence. +

        + Note that terminal notifications (onError and onComplete) trigger eviction as well. For + example, with a max age of 5, the first item is observed at T=0, then an onComplete notification + arrives at T=10. If a Subscriber subscribes at T=11, it will find an empty ReplayProcessor with just + an onComplete notification.

        +
        +
        Type Parameters:
        +
        T - the type of items observed and emitted by this type of processor
        +
        Parameters:
        +
        maxAge - the maximum age of the contained items
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that provides the current time
        +
        Returns:
        +
        the created processor
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if maxAge is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        createWithTimeAndSize

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull ReplayProcessor<T> createWithTimeAndSize(long maxAge,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        int maxSize)
        +
        Creates a time- and size-bounded ReplayProcessor. +

        + In this setting, the ReplayProcessor internally tags each received item with a timestamp value + supplied by the Scheduler and holds at most size items in its internal buffer. It evicts + items from the start of the buffer if their age becomes less-than or equal to the supplied age in + milliseconds or the buffer reaches its size limit. +

        + When Subscribers subscribe to a terminated ReplayProcessor, they observe the items that remained in + the buffer after the terminal notification, regardless of their age, but at most size items. +

        + If a Subscriber subscribes while the ReplayProcessor is active, it will observe only those items + from within the buffer that have age less than the specified time and each subsequent item, even if the + buffer evicts items due to the time constraint in the mean time. In other words, once a Subscriber + subscribes, it observes items without gaps in the sequence except for the outdated items at the beginning + of the sequence. +

        + Note that terminal notifications (onError and onComplete) trigger eviction as well. For + example, with a max age of 5, the first item is observed at T=0, then an onComplete notification + arrives at T=10. If a Subscriber subscribes at T=11, it will find an empty ReplayProcessor with just + an onComplete notification.

        +
        +
        Type Parameters:
        +
        T - the type of items observed and emitted by this type of processor
        +
        Parameters:
        +
        maxAge - the maximum age of the contained items
        +
        unit - the time unit of time
        +
        maxSize - the maximum number of buffered items
        +
        scheduler - the Scheduler that provides the current time
        +
        Returns:
        +
        the created processor
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if maxAge or maxSize is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        subscribeActual

        +
        protected void subscribeActual(Subscriber<? super T> s)
        +
        Description copied from class: Flowable
        +
        Operator implementations (both source and intermediate) should implement this method that + performs the necessary business logic and handles the incoming Subscribers. +

        There is no need to call any of the plugin hooks on the current Flowable instance or + the Subscriber; all hooks and basic safeguards have been + applied by Flowable.subscribe(Subscriber) before this method gets called.

        +
        +
        Specified by:
        +
        subscribeActual in class Flowable<T>
        +
        Parameters:
        +
        s - the incoming Subscriber, never null
        +
        +
        • +
      + + + +
        +
      • +

        onSubscribe

        +
        public void onSubscribe(Subscription s)
        +
        Description copied from interface: FlowableSubscriber
        +
        Implementors of this method should make sure everything that needs + to be visible in Subscriber.onNext(Object) is established before + calling Subscription.request(long). In practice this means + no initialization should happen after the request() call and + additional behavior is thread safe in respect to onNext. + +
        +
        • +
      + + + + + +
        +
      • +

        onNext

        +
        public void onNext(T t)
        +
        • +
      + + + +
        +
      • +

        onError

        +
        public void onError(Throwable t)
        +
        • +
      + + + +
        +
      • +

        onComplete

        +
        public void onComplete()
        +
        • +
      + + + +
        +
      • +

        hasSubscribers

        +
        @CheckReturnValue
+public boolean hasSubscribers()
        +
        Description copied from class: FlowableProcessor
        +
        Returns true if the FlowableProcessor has subscribers. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasSubscribers in class FlowableProcessor<T>
        +
        Returns:
        +
        true if the FlowableProcessor has subscribers
        +
        +
        • +
      + + + +
        +
      • +

        getThrowable

        +
        @Nullable
+ @CheckReturnValue
+public @Nullable Throwable getThrowable()
        +
        Description copied from class: FlowableProcessor
        +
        Returns the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor + hasn't terminated yet. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        getThrowable in class FlowableProcessor<T>
        +
        Returns:
        +
        the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor + hasn't terminated yet
        +
        +
        • +
      + + + +
        +
      • +

        cleanupBuffer

        +
        public void cleanupBuffer()
        +
        Makes sure the item cached by the head node in a bounded + ReplayProcessor is released (as it is never part of a replay). +

        + By default, live bounded buffers will remember one item before + the currently receivable one to ensure subscribers can always + receive a continuous sequence of items. A terminated ReplayProcessor + automatically releases this inaccessible item. +

        + The method must be called sequentially, similar to the standard + onXXX methods. +

        History: 2.1.11 - experimental

        +
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        getValue

        +
        @CheckReturnValue
+public T getValue()
        +
        Returns the latest value this processor has or null if no such value exists. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        the latest value this processor currently has or null if no such value exists
        +
        +
        • +
      + + + +
        +
      • +

        getValues

        +
        @CheckReturnValue
+public Object[] getValues()
        +
        Returns an Object array containing snapshot all values of this processor. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        the array containing the snapshot of all values of this processor
        +
        +
        • +
      + + + + + +
        +
      • +

        getValues

        +
        @CheckReturnValue
+public T[] getValues(T[] array)
        +
        Returns a typed array containing a snapshot of all values of this processor. +

        The method follows the conventions of Collection.toArray by setting the array element + after the last value to null (if the capacity permits). +

        The method is thread-safe.

        +
        +
        Parameters:
        +
        array - the target array to copy values into if it fits
        +
        Returns:
        +
        the given array if the values fit into it or a new array containing all values
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        hasValue

        +
        @CheckReturnValue
+public boolean hasValue()
        +
        Returns true if this processor has any value. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        true if the processor has any value
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/UnicastProcessor.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/UnicastProcessor.html new file mode 100644 index 0000000000..9bd578bd0e --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/UnicastProcessor.html @@ -0,0 +1,748 @@ + + + + + +UnicastProcessor (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.processors
+

Class UnicastProcessor<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type received and emitted by this Processor subclass
    +
    +
    +
    All Implemented Interfaces:
    +
    FlowableSubscriber<T>, Processor<T,T>, Publisher<T>, Subscriber<T>
    +
    +
    +
    +
    public final class UnicastProcessor<T>
+extends FlowableProcessor<T>
    +
    A FlowableProcessor variant that queues up events until a single Subscriber subscribes to it, replays + those events to it until the Subscriber catches up and then switches to relaying events live to + this single Subscriber until this UnicastProcessor terminates or the Subscriber cancels + its subscription. +

    + +

    + This processor does not have a public constructor by design; a new empty instance of this + UnicastProcessor can be created via the following create methods that + allow specifying the retention policy for items: +

      +
    • create() - creates an empty, unbounded UnicastProcessor that + caches all items and the terminal event it receives.
      • +
    • create(int) - creates an empty, unbounded UnicastProcessor + with a hint about how many total items one expects to retain.
      • +
    • create(boolean) - creates an empty, unbounded UnicastProcessor that + optionally delays an error it receives and replays it after the regular items have been emitted.
      • +
    • create(int, Runnable) - creates an empty, unbounded UnicastProcessor + with a hint about how many total items one expects to retain and a callback that will be + called exactly once when the UnicastProcessor gets terminated or the single Subscriber cancels.
      • +
    • create(int, Runnable, boolean) - creates an empty, unbounded UnicastProcessor + with a hint about how many total items one expects to retain and a callback that will be + called exactly once when the UnicastProcessor gets terminated or the single Subscriber cancels + and optionally delays an error it receives and replays it after the regular items have been emitted.
      • +
    +

    + If more than one Subscriber attempts to subscribe to this Processor, they + will receive an IllegalStateException if this UnicastProcessor hasn't terminated yet, + or the Subscribers receive the terminal event (error or completion) if this + Processor has terminated. +

    + The UnicastProcessor buffers notifications and replays them to the single Subscriber as requested, + for which it holds upstream items an unbounded internal buffer until they can be emitted. +

    + Since a UnicastProcessor is a Reactive Streams Processor, + nulls are not allowed (Rule 2.13) as + parameters to onNext(Object) and onError(Throwable). Such calls will result in a + NullPointerException being thrown and the processor's state is not changed. +

    + Since a UnicastProcessor is a Flowable as well as a FlowableProcessor, it + honors the downstream backpressure but consumes an upstream source in an unbounded manner (requesting Long.MAX_VALUE). +

    + When this UnicastProcessor is terminated via onError(Throwable) the current or late single Subscriber + may receive the Throwable before any available items could be emitted. To make sure an onError event is delivered + to the Subscriber after the normal items, create a UnicastProcessor with the create(boolean) or + create(int, Runnable, boolean) factory methods. +

    + Even though UnicastProcessor implements the Subscriber interface, calling + onSubscribe is not required (Rule 2.12) + if the processor is used as a standalone source. However, calling onSubscribe + after the UnicastProcessor reached its terminal state will result in the + given Subscription being canceled immediately. +

    + Calling onNext(Object), onError(Throwable) and onComplete() + is required to be serialized (called from the same thread or called non-overlappingly from different threads + through external means of serialization). The FlowableProcessor.toSerialized() method available to all FlowableProcessors + provides such serialization and also protects against reentrance (i.e., when a downstream Subscriber + consuming this processor also wants to call onNext(Object) on this processor recursively). +

    + This UnicastProcessor supports the standard state-peeking methods hasComplete(), hasThrowable(), + getThrowable() and hasSubscribers(). +

    +
    Backpressure:
    +
    UnicastProcessor honors the downstream backpressure but consumes an upstream source + (if any) in an unbounded manner (requesting Long.MAX_VALUE).
    +
    Scheduler:
    +
    UnicastProcessor does not operate by default on a particular Scheduler and + the single Subscriber gets notified on the thread the respective onXXX methods were invoked.
    +
    Error handling:
    +
    When the onError(Throwable) is called, the UnicastProcessor enters into a terminal state + and emits the same Throwable instance to the current single Subscriber. During this emission, + if the single Subscribers cancels its respective Subscriptions, the + Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable). + If there were no Subscribers subscribed to this UnicastProcessor when the onError() + was called, the global error handler is not invoked. +
    +
    +

    + Example usage: + 

    
+ UnicastProcessor<Integer> processor = UnicastProcessor.create();
+
+ TestSubscriber<Integer> ts1 = processor.test();
+
+ // fresh UnicastProcessors are empty
+ ts1.assertEmpty();
+
+ TestSubscriber<Integer> ts2 = processor.test();
+
+ // A UnicastProcessor only allows one Subscriber during its lifetime
+ ts2.assertFailure(IllegalStateException.class);
+
+ processor.onNext(1);
+ ts1.assertValue(1);
+
+ processor.onNext(2);
+ ts1.assertValues(1, 2);
+
+ processor.onComplete();
+ ts1.assertResult(1, 2);
+
+ // ----------------------------------------------------
+
+ UnicastProcessor<Integer> processor2 = UnicastProcessor.create();
+
+ // a UnicastProcessor caches events until its single Subscriber subscribes
+ processor2.onNext(1);
+ processor2.onNext(2);
+ processor2.onComplete();
+
+ TestSubscriber<Integer> ts3 = processor2.test();
+
+ // the cached events are emitted in order
+ ts3.assertResult(1, 2);
+
    +
    +
    Since:
    +
    2.0
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull UnicastProcessor<T> create()
        +
        Creates an UnicastSubject with an internal buffer capacity hint 16.
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Returns:
        +
        an UnicastSubject instance
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull UnicastProcessor<T> create(int capacityHint)
        +
        Creates an UnicastProcessor with the given internal buffer capacity hint.
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        capacityHint - the hint to size the internal unbounded buffer
        +
        Returns:
        +
        an UnicastProcessor instance
        +
        Throws:
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull UnicastProcessor<T> create(boolean delayError)
        +
        Creates an UnicastProcessor with default internal buffer capacity hint and delay error flag. +

        History: 2.0.8 - experimental

        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        delayError - deliver pending onNext events before onError
        +
        Returns:
        +
        an UnicastProcessor instance
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull UnicastProcessor<T> create(int capacityHint,
+        @NonNull Runnable onTerminate)
        +
        Creates an UnicastProcessor with the given internal buffer capacity hint and a callback for + the case when the single Subscriber cancels its subscription or the + processor is terminated. + +

        The callback, if not null, is called exactly once and + non-overlapped with any active replay.

        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        capacityHint - the hint to size the internal unbounded buffer
        +
        onTerminate - the non null callback
        +
        Returns:
        +
        an UnicastProcessor instance
        +
        Throws:
        +
        NullPointerException - if onTerminate is null
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull UnicastProcessor<T> create(int capacityHint,
+        @NonNull Runnable onTerminate,
+        boolean delayError)
        +
        Creates an UnicastProcessor with the given internal buffer capacity hint, delay error flag and a callback for + the case when the single Subscriber cancels its subscription or + the processor is terminated. + +

        The callback, if not null, is called exactly once and + non-overlapped with any active replay. +

        History: 2.0.8 - experimental

        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        capacityHint - the hint to size the internal unbounded buffer
        +
        onTerminate - the non null callback
        +
        delayError - deliver pending onNext events before onError
        +
        Returns:
        +
        an UnicastProcessor instance
        +
        Throws:
        +
        NullPointerException - if onTerminate is null
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        onSubscribe

        +
        public void onSubscribe(Subscription s)
        +
        Description copied from interface: FlowableSubscriber
        +
        Implementors of this method should make sure everything that needs + to be visible in Subscriber.onNext(Object) is established before + calling Subscription.request(long). In practice this means + no initialization should happen after the request() call and + additional behavior is thread safe in respect to onNext. + +
        +
        • +
      + + + + + +
        +
      • +

        onNext

        +
        public void onNext(T t)
        +
        • +
      + + + +
        +
      • +

        onError

        +
        public void onError(Throwable t)
        +
        • +
      + + + +
        +
      • +

        onComplete

        +
        public void onComplete()
        +
        • +
      + + + +
        +
      • +

        subscribeActual

        +
        protected void subscribeActual(Subscriber<? super T> s)
        +
        Description copied from class: Flowable
        +
        Operator implementations (both source and intermediate) should implement this method that + performs the necessary business logic and handles the incoming Subscribers. +

        There is no need to call any of the plugin hooks on the current Flowable instance or + the Subscriber; all hooks and basic safeguards have been + applied by Flowable.subscribe(Subscriber) before this method gets called.

        +
        +
        Specified by:
        +
        subscribeActual in class Flowable<T>
        +
        Parameters:
        +
        s - the incoming Subscriber, never null
        +
        +
        • +
      + + + +
        +
      • +

        hasSubscribers

        +
        @CheckReturnValue
+public boolean hasSubscribers()
        +
        Description copied from class: FlowableProcessor
        +
        Returns true if the FlowableProcessor has subscribers. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasSubscribers in class FlowableProcessor<T>
        +
        Returns:
        +
        true if the FlowableProcessor has subscribers
        +
        +
        • +
      + + + +
        +
      • +

        getThrowable

        +
        @Nullable
+ @CheckReturnValue
+public @Nullable Throwable getThrowable()
        +
        Description copied from class: FlowableProcessor
        +
        Returns the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor + hasn't terminated yet. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        getThrowable in class FlowableProcessor<T>
        +
        Returns:
        +
        the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor + hasn't terminated yet
        +
        +
        • +
      + + + + + + + + +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/package-frame.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/package-frame.html new file mode 100644 index 0000000000..b49c0b6dda --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/package-frame.html @@ -0,0 +1,25 @@ + + + + + +io.reactivex.rxjava3.processors (RxJava Javadoc 3.1.8) + + + + +

io.reactivex.rxjava3.processors

+
+

Classes

+ +
+ + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/package-summary.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/package-summary.html new file mode 100644 index 0000000000..6aa416d10e --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/package-summary.html @@ -0,0 +1,220 @@ + + + + + +io.reactivex.rxjava3.processors (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Package io.reactivex.rxjava3.processors

+
+
Classes representing so-called hot backpressure-aware sources, aka processors, + that implement the FlowableProcessor class, + the Reactive Streams Processor interface + to allow forms of multicasting events to one or more subscribers as well as consuming another + Reactive Streams Publisher.
+
+

See: Description

+
+
+ + + + +

Package io.reactivex.rxjava3.processors Description

+
Classes representing so-called hot backpressure-aware sources, aka processors, + that implement the FlowableProcessor class, + the Reactive Streams Processor interface + to allow forms of multicasting events to one or more subscribers as well as consuming another + Reactive Streams Publisher. +

+ Available processor implementations: +
+

+

+ The non-backpressured variants of the FlowableProcessor class are called + Subjects and reside in the io.reactivex.subjects package.

+
+
See Also:
+
io.reactivex.rxjava3.subjects
+
+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/package-tree.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/package-tree.html new file mode 100644 index 0000000000..c0e0826162 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/processors/package-tree.html @@ -0,0 +1,147 @@ + + + + + +io.reactivex.rxjava3.processors Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For Package io.reactivex.rxjava3.processors

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/SchedulerRunnableIntrospection.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/SchedulerRunnableIntrospection.html new file mode 100644 index 0000000000..64a4dd2bab --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/SchedulerRunnableIntrospection.html @@ -0,0 +1,240 @@ + + + + + +SchedulerRunnableIntrospection (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.schedulers
+

Interface SchedulerRunnableIntrospection

+
+
+
+
    +
  • +
    +
    +
    public interface SchedulerRunnableIntrospection
    +
    Interface to indicate the implementor class wraps a Runnable that can + be accessed via getWrappedRunnable(). +

    + You can check if a Runnable task submitted to a Scheduler (or its + Scheduler.Worker) implements this interface and unwrap the + original Runnable instance. This could help to avoid hooking the same underlying Runnable + task in a custom RxJavaPlugins.onSchedule(Runnable) hook set via + the RxJavaPlugins.setScheduleHandler(Function) method multiple times due to internal delegation + of the default Scheduler.scheduleDirect or Scheduler.Worker.schedule methods. +

    History: 2.1.7 - experimental

    +
    +
    Since:
    +
    2.2
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        getWrappedRunnable

        +
        @NonNull
+@NonNull Runnable getWrappedRunnable()
        +
        Returns the wrapped action.
        +
        +
        Returns:
        +
        the wrapped action. Cannot be null.
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/Schedulers.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/Schedulers.html new file mode 100644 index 0000000000..f0cf750084 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/Schedulers.html @@ -0,0 +1,857 @@ + + + + + +Schedulers (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.schedulers
+

Class Schedulers

+
+
+ +
+
    +
  • +
    +
    +
    public final class Schedulers
+extends Object
    +
    Static factory methods for returning standard Scheduler instances. +

    + The initial and runtime values of the various scheduler types can be overridden via the + RxJavaPlugins.setInit(scheduler name)SchedulerHandler() and + RxJavaPlugins.set(scheduler name)SchedulerHandler() respectively. + Note that overriding any initial Scheduler via the RxJavaPlugins + has to happen before the Schedulers class is accessed. +

    + Supported system properties (System.getProperty()): +

      +
    • rx3.io-keep-alive-time (long): sets the keep-alive time of the io() Scheduler workers, default is IoScheduler.KEEP_ALIVE_TIME_DEFAULT
      • +
    • rx3.io-priority (int): sets the thread priority of the io() Scheduler, default is Thread.NORM_PRIORITY
      • +
    • rx3.io-scheduled-release (boolean): true sets the worker release mode of the + io() Scheduler to scheduled, default is false for eager mode.
      • +
    • rx3.computation-threads (int): sets the number of threads in the computation() Scheduler, default is the number of available CPUs
      • +
    • rx3.computation-priority (int): sets the thread priority of the computation() Scheduler, default is Thread.NORM_PRIORITY
      • +
    • rx3.newthread-priority (int): sets the thread priority of the newThread() Scheduler, default is Thread.NORM_PRIORITY
      • +
    • rx3.single-priority (int): sets the thread priority of the single() Scheduler, default is Thread.NORM_PRIORITY
      • +
    • rx3.purge-enabled (boolean): enables purging of all Scheduler's backing thread pools, default is true
      • +
    • rx3.scheduler.use-nanotime (boolean): true instructs Scheduler to use System.nanoTime() for Scheduler.now(TimeUnit), + instead of default System.currentTimeMillis() (false)
      • +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        io

        +
        @NonNull
+public static @NonNull Scheduler io()
        +
        Returns a default, shared Scheduler instance intended for IO-bound work. +

        + This can be used for asynchronously performing blocking IO. +

        + The implementation is backed by a pool of single-threaded ScheduledExecutorService instances + that will try to reuse previously started instances used by the worker + returned by Scheduler.createWorker() but otherwise will start a new backing + ScheduledExecutorService instance. Note that this scheduler may create an unbounded number + of worker threads that can result in system slowdowns or OutOfMemoryError. Therefore, for casual uses + or when implementing an operator, the Worker instances must be disposed via Disposable.dispose(). +

        + It is not recommended to perform computational work on this scheduler. Use computation() instead. +

        + Unhandled errors will be delivered to the scheduler Thread's Thread.UncaughtExceptionHandler. +

        + You can control certain properties of this standard scheduler via system properties that have to be set + before the Schedulers class is referenced in your code. +

        Supported system properties (System.getProperty()): +

          +
        • rx3.io-keep-alive-time (long): sets the keep-alive time of the io() Scheduler workers, default is IoScheduler.KEEP_ALIVE_TIME_DEFAULT
          • +
        • rx3.io-priority (int): sets the thread priority of the io() Scheduler, default is Thread.NORM_PRIORITY
          • +
        • rx3.io-scheduled-release (boolean): true sets the worker release mode of the + #io() Scheduler to scheduled, default is false for eager mode.
          • +
        +

        + The default value of this scheduler can be overridden at initialization time via the + RxJavaPlugins.setInitIoSchedulerHandler(io.reactivex.rxjava3.functions.Function) plugin method. + Note that due to possible initialization cycles, using any of the other scheduler-returning methods will + result in a NullPointerException. + Once the Schedulers class has been initialized, you can override the returned Scheduler instance + via the RxJavaPlugins.setIoSchedulerHandler(io.reactivex.rxjava3.functions.Function) method. +

        + It is possible to create a fresh instance of this scheduler with a custom ThreadFactory, via the + RxJavaPlugins.createIoScheduler(ThreadFactory) method. Note that such custom + instances require a manual call to Scheduler.shutdown() to allow the JVM to exit or the + (J2EE) container to unload properly. +

        Operators on the base reactive classes that use this scheduler are marked with the + @SchedulerSupport(IO) + annotation. +

        + When the Scheduler.Worker is disposed, + the underlying worker can be released to the cached worker pool in two modes: +

          +
        • In eager mode (default), the underlying worker is returned immediately to the cached worker pool + and can be reused much quicker by operators. The drawback is that if the currently running task doesn't + respond to interruption in time or at all, this may lead to delays or deadlock with the reuse use of the + underlying worker. +
          • +
        • In scheduled mode (enabled via the system parameter rx3.io-scheduled-release + set to true), the underlying worker is returned to the cached worker pool only after the currently running task + has finished. This can help prevent premature reuse of the underlying worker and likely won't lead to delays or + deadlock with such reuses. The drawback is that the delay in release may lead to an excess amount of underlying + workers being created. +
          • +
        +
        +
        Returns:
        +
        a Scheduler meant for IO-bound work
        +
        +
        • +
      + + + +
        +
      • +

        trampoline

        +
        @NonNull
+public static @NonNull Scheduler trampoline()
        +
        Returns a default, shared Scheduler instance whose Scheduler.Worker + instances queue work and execute them in a FIFO manner on one of the participating threads. +

        + The default implementation's Scheduler.scheduleDirect(Runnable) methods execute the tasks on the current thread + without any queueing and the timed overloads use blocking sleep as well. +

        + Note that this scheduler can't be reliably used to return the execution of + tasks to the "main" thread. Such behavior requires a blocking-queueing scheduler currently not provided + by RxJava itself but may be found in external libraries. +

        + This scheduler can't be overridden via an RxJavaPlugins method.

        +
        +
        Returns:
        +
        a Scheduler that queues work on the current thread
        +
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        from

        +
        @NonNull
+public static @NonNull Scheduler from(@NonNull
+                                               @NonNull Executor executor)
        +
        Wraps an Executor into a new Scheduler instance and delegates schedule() + calls to it. +

        + If the provided executor doesn't support any of the more specific standard Java executor + APIs, tasks scheduled by this scheduler can't be interrupted when they are + executing but only prevented from running prior to that. In addition, tasks scheduled with + a time delay or periodically will use the single() scheduler for the timed waiting + before posting the actual task to the given executor. +

        + Tasks submitted to the Scheduler.Worker of this Scheduler are also not interruptible. Use the + from(Executor, boolean) overload to enable task interruption via this wrapper. +

        + If the provided executor supports the standard Java ExecutorService API, + tasks scheduled by this scheduler can be cancelled/interrupted by calling + Disposable.dispose(). In addition, tasks scheduled with + a time delay or periodically will use the single() scheduler for the timed waiting + before posting the actual task to the given executor. +

        + If the provided executor supports the standard Java ScheduledExecutorService API, + tasks scheduled by this scheduler can be cancelled/interrupted by calling + Disposable.dispose(). In addition, tasks scheduled with + a time delay or periodically will use the provided executor. Note, however, if the provided + ScheduledExecutorService instance is not single threaded, tasks scheduled + with a time delay close to each other may end up executing in different order than + the original schedule() call was issued. This limitation may be lifted in a future patch. +

        + The implementation of the Worker of this wrapper Scheduler is eager and will execute as many + non-delayed tasks as it can, which may result in a longer than expected occupation of a + thread of the given backing Executor. In other terms, it does not allow per-Runnable fairness + in case the worker runs on a shared underlying thread of the Executor. + See from(Executor, boolean, boolean) to create a wrapper that uses the underlying Executor + more fairly. +

        + Starting, stopping and restarting this scheduler is not supported (no-op) and the provided + executor's lifecycle must be managed externally: + 

        
+ ExecutorService exec = Executors.newSingleThreadedExecutor();
+ try {
+     Scheduler scheduler = Schedulers.from(exec);
+     Flowable.just(1)
+        .subscribeOn(scheduler)
+        .map(v -> v + 1)
+        .observeOn(scheduler)
+        .blockingSubscribe(System.out::println);
+ } finally {
+     exec.shutdown();
+ }
+
        +

        + Note that the provided Executor should avoid throwing a RejectedExecutionException + (for example, by shutting it down prematurely or using a bounded-queue ExecutorService) + because such circumstances prevent RxJava from progressing flow-related activities correctly. + If the Executor.execute(Runnable) or ExecutorService.submit(Callable) throws, + the RejectedExecutionException is routed to the global error handler via + RxJavaPlugins.onError(Throwable). To avoid shutdown-related problems, it is recommended + all flows using the returned Scheduler to be canceled/disposed before the underlying + Executor is shut down. To avoid problems due to the Executor having a bounded-queue, + it is recommended to rephrase the flow to utilize backpressure as the means to limit outstanding work. +

        + This type of scheduler is less sensitive to leaking Scheduler.Worker instances, although + not disposing a worker that has timed/delayed tasks not cancelled by other means may leak resources and/or + execute those tasks "unexpectedly". +

        + Note that this method returns a new Scheduler instance, even for the same Executor instance. +

        + It is possible to wrap an Executor into a Scheduler without triggering the initialization of all the + standard schedulers by using the RxJavaPlugins.createExecutorScheduler(Executor, boolean, boolean) method + before the Schedulers class itself is accessed.

        +
        +
        Parameters:
        +
        executor - the executor to wrap
        +
        Returns:
        +
        the new Scheduler wrapping the Executor
        +
        See Also:
        +
        from(Executor, boolean, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        from

        +
        @NonNull
+public static @NonNull Scheduler from(@NonNull
+                                               @NonNull Executor executor,
+                                               boolean interruptibleWorker)
        +
        Wraps an Executor into a new Scheduler instance and delegates schedule() + calls to it. +

        + The tasks scheduled by the returned Scheduler and its Scheduler.Worker + can be optionally interrupted. +

        + If the provided executor doesn't support any of the more specific standard Java executor + APIs, tasks scheduled with a time delay or periodically will use the + single() scheduler for the timed waiting + before posting the actual task to the given executor. +

        + If the provided executor supports the standard Java ExecutorService API, + tasks scheduled by this scheduler can be cancelled/interrupted by calling + Disposable.dispose(). In addition, tasks scheduled with + a time delay or periodically will use the single() scheduler for the timed waiting + before posting the actual task to the given executor. +

        + If the provided executor supports the standard Java ScheduledExecutorService API, + tasks scheduled by this scheduler can be cancelled/interrupted by calling + Disposable.dispose(). In addition, tasks scheduled with + a time delay or periodically will use the provided executor. Note, however, if the provided + ScheduledExecutorService instance is not single threaded, tasks scheduled + with a time delay close to each other may end up executing in different order than + the original schedule() call was issued. This limitation may be lifted in a future patch. +

        + The implementation of the Worker of this wrapper Scheduler is eager and will execute as many + non-delayed tasks as it can, which may result in a longer than expected occupation of a + thread of the given backing Executor. In other terms, it does not allow per-Runnable fairness + in case the worker runs on a shared underlying thread of the Executor. + See from(Executor, boolean, boolean) to create a wrapper that uses the underlying Executor + more fairly. +

        + Starting, stopping and restarting this scheduler is not supported (no-op) and the provided + executor's lifecycle must be managed externally: + 

        
+ ExecutorService exec = Executors.newSingleThreadedExecutor();
+ try {
+     Scheduler scheduler = Schedulers.from(exec, true);
+     Flowable.just(1)
+        .subscribeOn(scheduler)
+        .map(v -> v + 1)
+        .observeOn(scheduler)
+        .blockingSubscribe(System.out::println);
+ } finally {
+     exec.shutdown();
+ }
+
        +

        + Note that the provided Executor should avoid throwing a RejectedExecutionException + (for example, by shutting it down prematurely or using a bounded-queue ExecutorService) + because such circumstances prevent RxJava from progressing flow-related activities correctly. + If the Executor.execute(Runnable) or ExecutorService.submit(Callable) throws, + the RejectedExecutionException is routed to the global error handler via + RxJavaPlugins.onError(Throwable). To avoid shutdown-related problems, it is recommended + all flows using the returned Scheduler to be canceled/disposed before the underlying + Executor is shut down. To avoid problems due to the Executor having a bounded-queue, + it is recommended to rephrase the flow to utilize backpressure as the means to limit outstanding work. +

        + This type of scheduler is less sensitive to leaking Scheduler.Worker instances, although + not disposing a worker that has timed/delayed tasks not cancelled by other means may leak resources and/or + execute those tasks "unexpectedly". +

        + Note that this method returns a new Scheduler instance, even for the same Executor instance. +

        + It is possible to wrap an Executor into a Scheduler without triggering the initialization of all the + standard schedulers by using the RxJavaPlugins.createExecutorScheduler(Executor, boolean, boolean) method + before the Schedulers class itself is accessed. +

        History: 2.2.6 - experimental

        +
        +
        Parameters:
        +
        executor - the executor to wrap
        +
        interruptibleWorker - if true, the tasks submitted to the Scheduler.Worker will + be interrupted when the task is disposed.
        +
        Returns:
        +
        the new Scheduler wrapping the Executor
        +
        Since:
        +
        3.0.0
        +
        See Also:
        +
        from(Executor, boolean, boolean)
        +
        +
        • +
      + + + +
        +
      • +

        from

        +
        @NonNull
+public static @NonNull Scheduler from(@NonNull
+                                               @NonNull Executor executor,
+                                               boolean interruptibleWorker,
+                                               boolean fair)
        +
        Wraps an Executor into a new Scheduler instance and delegates schedule() + calls to it. +

        + The tasks scheduled by the returned Scheduler and its Scheduler.Worker + can be optionally interrupted. +

        + If the provided executor doesn't support any of the more specific standard Java executor + APIs, tasks scheduled with a time delay or periodically will use the + single() scheduler for the timed waiting + before posting the actual task to the given executor. +

        + If the provided executor supports the standard Java ExecutorService API, + tasks scheduled by this scheduler can be cancelled/interrupted by calling + Disposable.dispose(). In addition, tasks scheduled with + a time delay or periodically will use the single() scheduler for the timed waiting + before posting the actual task to the given executor. +

        + If the provided executor supports the standard Java ScheduledExecutorService API, + tasks scheduled by this scheduler can be cancelled/interrupted by calling + Disposable.dispose(). In addition, tasks scheduled with + a time delay or periodically will use the provided executor. Note, however, if the provided + ScheduledExecutorService instance is not single threaded, tasks scheduled + with a time delay close to each other may end up executing in different order than + the original schedule() call was issued. This limitation may be lifted in a future patch. +

        + The implementation of the Worker of this wrapper Scheduler can operate in both eager (non-fair) and + fair modes depending on the specified parameter. In eager mode, it will execute as many + non-delayed tasks as it can, which may result in a longer than expected occupation of a + thread of the given backing Executor. In other terms, it does not allow per-Runnable fairness + in case the worker runs on a shared underlying thread of the Executor. In fair mode, + non-delayed tasks will still be executed in a FIFO and non-overlapping manner, but after each task, + the execution for the next task is rescheduled with the same underlying Executor, allowing interleaving + from both the same Scheduler or other external usages of the underlying Executor. +

        + Starting, stopping and restarting this scheduler is not supported (no-op) and the provided + executor's lifecycle must be managed externally: + 

        
+ ExecutorService exec = Executors.newSingleThreadedExecutor();
+ try {
+     Scheduler scheduler = Schedulers.from(exec, true, true);
+     Flowable.just(1)
+        .subscribeOn(scheduler)
+        .map(v -> v + 1)
+        .observeOn(scheduler)
+        .blockingSubscribe(System.out::println);
+ } finally {
+     exec.shutdown();
+ }
+
        +

        + Note that the provided Executor should avoid throwing a RejectedExecutionException + (for example, by shutting it down prematurely or using a bounded-queue ExecutorService) + because such circumstances prevent RxJava from progressing flow-related activities correctly. + If the Executor.execute(Runnable) or ExecutorService.submit(Callable) throws, + the RejectedExecutionException is routed to the global error handler via + RxJavaPlugins.onError(Throwable). To avoid shutdown-related problems, it is recommended + all flows using the returned Scheduler to be canceled/disposed before the underlying + Executor is shut down. To avoid problems due to the Executor having a bounded-queue, + it is recommended to rephrase the flow to utilize backpressure as the means to limit outstanding work. +

        + This type of scheduler is less sensitive to leaking Scheduler.Worker instances, although + not disposing a worker that has timed/delayed tasks not cancelled by other means may leak resources and/or + execute those tasks "unexpectedly". +

        + Note that this method returns a new Scheduler instance, even for the same Executor instance. +

        + It is possible to wrap an Executor into a Scheduler without triggering the initialization of all the + standard schedulers by using the RxJavaPlugins.createExecutorScheduler(Executor, boolean, boolean) method + before the Schedulers class itself is accessed.

        +
        +
        Parameters:
        +
        executor - the executor to wrap
        +
        interruptibleWorker - if true, the tasks submitted to the Scheduler.Worker will + be interrupted when the task is disposed.
        +
        fair - if true, tasks submitted to the Scheduler or Worker will be executed by the underlying Executor one after the other, still + in a FIFO and non-overlapping manner, but allows interleaving with other tasks submitted to the underlying Executor. + If false, the underlying FIFO scheme will execute as many tasks as it can before giving up the underlying Executor thread.
        +
        Returns:
        +
        the new Scheduler wrapping the Executor
        +
        Since:
        +
        3.0.0
        +
        +
        • +
      + + + +
        +
      • +

        shutdown

        +
        public static void shutdown()
        +
        Shuts down the standard Schedulers. +

        The operation is idempotent and thread-safe.

        +
        • +
      + + + +
        +
      • +

        start

        +
        public static void start()
        +
        Starts the standard Schedulers. +

        The operation is idempotent and thread-safe.

        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/TestScheduler.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/TestScheduler.html new file mode 100644 index 0000000000..5649dd46b4 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/TestScheduler.html @@ -0,0 +1,494 @@ + + + + + +TestScheduler (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + +
+
io.reactivex.rxjava3.schedulers
+

Class TestScheduler

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        TestScheduler

        +
        public TestScheduler()
        +
        Creates a new TestScheduler with initial virtual time of zero.
        +
        • +
      + + + +
        +
      • +

        TestScheduler

        +
        public TestScheduler(boolean useOnScheduleHook)
        +
        Creates a new TestScheduler with the option to use the + RxJavaPlugins.onSchedule(Runnable) hook when scheduling tasks. +

        History: 3.0.10 - experimental

        +
        +
        Parameters:
        +
        useOnScheduleHook - if true, the tasks submitted to this + TestScheduler is wrapped via the + RxJavaPlugins.onSchedule(Runnable) hook
        +
        Since:
        +
        3.1.0
        +
        +
        • +
      + + + +
        +
      • +

        TestScheduler

        +
        public TestScheduler(long delayTime,
+                     TimeUnit unit)
        +
        Creates a new TestScheduler with the specified initial virtual time.
        +
        +
        Parameters:
        +
        delayTime - the point in time to move the Scheduler's clock to
        +
        unit - the units of time that delayTime is expressed in
        +
        +
        • +
      + + + +
        +
      • +

        TestScheduler

        +
        public TestScheduler(long delayTime,
+                     TimeUnit unit,
+                     boolean useOnScheduleHook)
        +
        Creates a new TestScheduler with the specified initial virtual time + and with the option to use the + RxJavaPlugins.onSchedule(Runnable) hook when scheduling tasks. +

        History: 3.0.10 - experimental

        +
        +
        Parameters:
        +
        delayTime - the point in time to move the Scheduler's clock to
        +
        unit - the units of time that delayTime is expressed in
        +
        useOnScheduleHook - if true, the tasks submitted to this + TestScheduler is wrapped via the + RxJavaPlugins.onSchedule(Runnable) hook
        +
        Since:
        +
        3.1.0
        +
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        now

        +
        public long now(@NonNull
+                @NonNull TimeUnit unit)
        +
        Description copied from class: Scheduler
        +
        Returns the 'current time' of the Scheduler in the specified time unit.
        +
        +
        Overrides:
        +
        now in class Scheduler
        +
        Parameters:
        +
        unit - the time unit
        +
        Returns:
        +
        the 'current time'
        +
        +
        • +
      + + + +
        +
      • +

        advanceTimeBy

        +
        public void advanceTimeBy(long delayTime,
+                          TimeUnit unit)
        +
        Moves the Scheduler's clock forward by a specified amount of time.
        +
        +
        Parameters:
        +
        delayTime - the amount of time to move the Scheduler's clock forward
        +
        unit - the units of time that delayTime is expressed in
        +
        +
        • +
      + + + +
        +
      • +

        advanceTimeTo

        +
        public void advanceTimeTo(long delayTime,
+                          TimeUnit unit)
        +
        Moves the Scheduler's clock to a particular moment in time.
        +
        +
        Parameters:
        +
        delayTime - the point in time to move the Scheduler's clock to
        +
        unit - the units of time that delayTime is expressed in
        +
        +
        • +
      + + + +
        +
      • +

        triggerActions

        +
        public void triggerActions()
        +
        Triggers any actions that have not yet been triggered and that are scheduled to be triggered at or + before this Scheduler's present time.
        +
        • +
      + + + +
        +
      • +

        createWorker

        +
        @NonNull
+public @NonNull Scheduler.Worker createWorker()
        +
        Description copied from class: Scheduler
        +
        Retrieves or creates a new Scheduler.Worker that represents sequential execution of actions. +

        + When work is completed, the Worker instance should be released + by calling Disposable.dispose() to avoid potential resource leaks in the + underlying task-execution scheme. +

        + Work on a Scheduler.Worker is guaranteed to be sequential and non-overlapping.

        +
        +
        Specified by:
        +
        createWorker in class Scheduler
        +
        Returns:
        +
        a Worker representing a serial queue of actions to be executed
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/Timed.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/Timed.html new file mode 100644 index 0000000000..505e3d23d7 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/Timed.html @@ -0,0 +1,415 @@ + + + + + +Timed (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.schedulers
+

Class Timed<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    +
    public final class Timed<T>
+extends Object
    +
    Holds onto a value along with time information.
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + + + +
        +
      • +

        Timed

        +
        public Timed(@NonNull
+             T value,
+             long time,
+             @NonNull
+             @NonNull TimeUnit unit)
        +
        Constructs a Timed instance with the given value and time information.
        +
        +
        Parameters:
        +
        value - the value to hold
        +
        time - the time to hold
        +
        unit - the time unit, not null
        +
        Throws:
        +
        NullPointerException - if value or unit is null
        +
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        value

        +
        @NonNull
+public T value()
        +
        Returns the contained value.
        +
        +
        Returns:
        +
        the contained value
        +
        +
        • +
      + + + +
        +
      • +

        unit

        +
        @NonNull
+public @NonNull TimeUnit unit()
        +
        Returns the time unit of the contained time.
        +
        +
        Returns:
        +
        the time unit of the contained time
        +
        +
        • +
      + + + +
        +
      • +

        time

        +
        public long time()
        +
        Returns the time value.
        +
        +
        Returns:
        +
        the time value
        +
        +
        • +
      + + + +
        +
      • +

        time

        +
        public long time(@NonNull
+                 @NonNull TimeUnit unit)
        +
        Returns the contained time value in the time unit specified.
        +
        +
        Parameters:
        +
        unit - the time unit
        +
        Returns:
        +
        the converted time
        +
        +
        • +
      + + + +
        +
      • +

        equals

        +
        public boolean equals(Object other)
        +
        +
        Overrides:
        +
        equals in class Object
        +
        +
        • +
      + + + +
        +
      • +

        hashCode

        +
        public int hashCode()
        +
        +
        Overrides:
        +
        hashCode in class Object
        +
        +
        • +
      + + + + +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/package-frame.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/package-frame.html new file mode 100644 index 0000000000..38b2c2f680 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/package-frame.html @@ -0,0 +1,25 @@ + + + + + +io.reactivex.rxjava3.schedulers (RxJava Javadoc 3.1.8) + + + + +

io.reactivex.rxjava3.schedulers

+
+

Interfaces

+ +

Classes

+ +
+ + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/package-summary.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/package-summary.html new file mode 100644 index 0000000000..e48d1f17d3 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/package-summary.html @@ -0,0 +1,188 @@ + + + + + +io.reactivex.rxjava3.schedulers (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Package io.reactivex.rxjava3.schedulers

+
+
Contains notably the factory class of Schedulers providing methods for + retrieving the standard scheduler instances, the TestScheduler for testing flows + with scheduling in a controlled manner and the class Timed that can hold + a value and a timestamp associated with it.
+
+

See: Description

+
+
+ + + + +

Package io.reactivex.rxjava3.schedulers Description

+
Contains notably the factory class of Schedulers providing methods for + retrieving the standard scheduler instances, the TestScheduler for testing flows + with scheduling in a controlled manner and the class Timed that can hold + a value and a timestamp associated with it.
+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/package-tree.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/package-tree.html new file mode 100644 index 0000000000..287ceb154d --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/schedulers/package-tree.html @@ -0,0 +1,144 @@ + + + + + +io.reactivex.rxjava3.schedulers Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For Package io.reactivex.rxjava3.schedulers

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +

Interface Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/AsyncSubject.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/AsyncSubject.html new file mode 100644 index 0000000000..2d89614224 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/AsyncSubject.html @@ -0,0 +1,635 @@ + + + + + +AsyncSubject (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.subjects
+

Class AsyncSubject<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    All Implemented Interfaces:
    +
    ObservableSource<T>, Observer<T>
    +
    +
    +
    +
    public final class AsyncSubject<T>
+extends Subject<T>
    +
    A Subject that emits the very last value followed by a completion event or the received error to Observers. +

    + +

    + This subject does not have a public constructor by design; a new empty instance of this + AsyncSubject can be created via the create() method. +

    + Since a Subject is conceptionally derived from the Processor type in the Reactive Streams specification, + nulls are not allowed (Rule 2.13) + as parameters to onNext(Object) and onError(Throwable). Such calls will result in a + NullPointerException being thrown and the subject's state is not changed. +

    + Since an AsyncSubject is an Observable, it does not support backpressure. +

    + When this AsyncSubject is terminated via onError(Throwable), the + last observed item (if any) is cleared and late Observers only receive + the onError event. +

    + The AsyncSubject caches the latest item internally and it emits this item only when onComplete is called. + Therefore, it is not recommended to use this Subject with infinite or never-completing sources. +

    + Even though AsyncSubject implements the Observer interface, calling + onSubscribe is not required (Rule 2.12) + if the subject is used as a standalone source. However, calling onSubscribe + after the AsyncSubject reached its terminal state will result in the + given Disposable being disposed immediately. +

    + Calling onNext(Object), onError(Throwable) and onComplete() + is required to be serialized (called from the same thread or called non-overlappingly from different threads + through external means of serialization). The Subject.toSerialized() method available to all Subjects + provides such serialization and also protects against reentrance (i.e., when a downstream Observer + consuming this subject also wants to call onNext(Object) on this subject recursively). + The implementation of onXXX methods are technically thread-safe but non-serialized calls + to them may lead to undefined state in the currently subscribed Observers. +

    + This AsyncSubject supports the standard state-peeking methods hasComplete(), hasThrowable(), + getThrowable() and hasObservers() as well as means to read the very last observed value - + after this AsyncSubject has been completed - in a non-blocking and thread-safe + manner via hasValue() or getValue(). +

    +
    Scheduler:
    +
    AsyncSubject does not operate by default on a particular Scheduler and + the Observers get notified on the thread where the terminating onError or onComplete + methods were invoked.
    +
    Error handling:
    +
    When the onError(Throwable) is called, the AsyncSubject enters into a terminal state + and emits the same Throwable instance to the last set of Observers. During this emission, + if one or more Observers dispose their respective Disposables, the + Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) (multiple times if multiple Observers + cancel at once). + If there were no Observers subscribed to this AsyncSubject when the onError() + was called, the global error handler is not invoked. +
    +
    +

    + Example usage: + 

    
+ AsyncSubject<Object> subject = AsyncSubject.create();
+ 
+ TestObserver<Object> to1 = subject.test();
+
+ to1.assertEmpty();
+
+ subject.onNext(1);
+
+ // AsyncSubject only emits when onComplete was called.
+ to1.assertEmpty();
+
+ subject.onNext(2);
+ subject.onComplete();
+
+ // onComplete triggers the emission of the last cached item and the onComplete event.
+ to1.assertResult(2);
+
+ TestObserver<Object> to2 = subject.test();
+
+ // late Observers receive the last cached item too
+ to2.assertResult(2);
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull AsyncSubject<T> create()
        +
        Creates a new AsyncProcessor.
        +
        +
        Type Parameters:
        +
        T - the value type to be received and emitted
        +
        Returns:
        +
        the new AsyncProcessor instance
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        hasObservers

        +
        @CheckReturnValue
+public boolean hasObservers()
        +
        Description copied from class: Subject
        +
        Returns true if the subject has any Observers. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasObservers in class Subject<T>
        +
        Returns:
        +
        true if the subject has any Observers
        +
        +
        • +
      + + + + + + + +
        +
      • +

        hasComplete

        +
        @CheckReturnValue
+public boolean hasComplete()
        +
        Description copied from class: Subject
        +
        Returns true if the subject has reached a terminal state through a complete event. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasComplete in class Subject<T>
        +
        Returns:
        +
        true if the subject has reached a terminal state through a complete event
        +
        See Also:
        +
        Subject.hasThrowable()
        +
        +
        • +
      + + + +
        +
      • +

        getThrowable

        +
        @CheckReturnValue
+public Throwable getThrowable()
        +
        Description copied from class: Subject
        +
        Returns the error that caused the Subject to terminate or null if the Subject + hasn't terminated yet. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        getThrowable in class Subject<T>
        +
        Returns:
        +
        the error that caused the Subject to terminate or null if the Subject + hasn't terminated yet
        +
        +
        • +
      + + + +
        +
      • +

        subscribeActual

        +
        protected void subscribeActual(Observer<? super T> observer)
        +
        Description copied from class: Observable
        +
        Operator implementations (both source and intermediate) should implement this method that + performs the necessary business logic and handles the incoming Observers. +

        There is no need to call any of the plugin hooks on the current Observable instance or + the Observer; all hooks and basic safeguards have been + applied by Observable.subscribe(Observer) before this method gets called.

        +
        +
        Specified by:
        +
        subscribeActual in class Observable<T>
        +
        Parameters:
        +
        observer - the incoming Observer, never null
        +
        +
        • +
      + + + +
        +
      • +

        hasValue

        +
        @CheckReturnValue
+public boolean hasValue()
        +
        Returns true if the subject has any value. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        true if the subject has any value
        +
        +
        • +
      + + + +
        +
      • +

        getValue

        +
        @Nullable
+ @CheckReturnValue
+public T getValue()
        +
        Returns a single value the Subject currently has or null if no such value exists. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        a single value the Subject currently has or null if no such value exists
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/BehaviorSubject.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/BehaviorSubject.html new file mode 100644 index 0000000000..d622f376a4 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/BehaviorSubject.html @@ -0,0 +1,707 @@ + + + + + +BehaviorSubject (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.subjects
+

Class BehaviorSubject<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the type of item expected to be observed by the Subject
    +
    +
    +
    All Implemented Interfaces:
    +
    ObservableSource<T>, Observer<T>
    +
    +
    +
    +
    public final class BehaviorSubject<T>
+extends Subject<T>
    +
    Subject that emits the most recent item it has observed and all subsequent observed items to each subscribed + Observer. +

    + +

    + This subject does not have a public constructor by design; a new empty instance of this + BehaviorSubject can be created via the create() method and + a new non-empty instance can be created via createDefault(Object) (named as such to avoid + overload resolution conflict with Observable.create that creates an Observable, not a BehaviorSubject). +

    + Since a Subject is conceptionally derived from the Processor type in the Reactive Streams specification, + nulls are not allowed (Rule 2.13) as + default initial values in createDefault(Object) or as parameters to onNext(Object) and + onError(Throwable). Such calls will result in a + NullPointerException being thrown and the subject's state is not changed. +

    + Since a BehaviorSubject is an Observable, it does not support backpressure. +

    + When this BehaviorSubject is terminated via onError(Throwable) or onComplete(), the + last observed item (if any) is cleared and late Observers only receive + the respective terminal event. +

    + The BehaviorSubject does not support clearing its cached value (to appear empty again), however, the + effect can be achieved by using a special item and making sure Observers subscribe through a + filter whose predicate filters out this special item: + 

    
+ BehaviorSubject<Integer> subject = BehaviorSubject.create();
+
+ final Integer EMPTY = Integer.MIN_VALUE;
+
+ Observable<Integer> observable = subject.filter(v -> v != EMPTY);
+
+ TestObserver<Integer> to1 = observable.test();
+
+ subject.onNext(1);
+ // this will "clear" the cache
+ subject.onNext(EMPTY);
+
+ TestObserver<Integer> to2 = observable.test();
+
+ subject.onNext(2);
+ subject.onComplete();
+
+ // to1 received both non-empty items
+ to1.assertResult(1, 2);
+
+ // to2 received only 2 even though the current item was EMPTY
+ // when it got subscribed
+ to2.assertResult(2);
+
+ // Observers coming after the subject was terminated receive
+ // no items and only the onComplete event in this case.
+ observable.test().assertResult();
+
    +

    + Even though BehaviorSubject implements the Observer interface, calling + onSubscribe is not required (Rule 2.12) + if the subject is used as a standalone source. However, calling onSubscribe + after the BehaviorSubject reached its terminal state will result in the + given Disposable being disposed immediately. +

    + Calling onNext(Object), onError(Throwable) and onComplete() + is required to be serialized (called from the same thread or called non-overlappingly from different threads + through external means of serialization). The Subject.toSerialized() method available to all Subjects + provides such serialization and also protects against reentrance (i.e., when a downstream Observer + consuming this subject also wants to call onNext(Object) on this subject recursively). +

    + This BehaviorSubject supports the standard state-peeking methods hasComplete(), hasThrowable(), + getThrowable() and hasObservers() as well as means to read the latest observed value + in a non-blocking and thread-safe manner via hasValue() or getValue(). +

    +
    Scheduler:
    +
    BehaviorSubject does not operate by default on a particular Scheduler and + the Observers get notified on the thread the respective onXXX methods were invoked.
    +
    Error handling:
    +
    When the onError(Throwable) is called, the BehaviorSubject enters into a terminal state + and emits the same Throwable instance to the last set of Observers. During this emission, + if one or more Observers dispose their respective Disposables, the + Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) (multiple times if multiple Observers + cancel at once). + If there were no Observers subscribed to this BehaviorSubject when the onError() + was called, the global error handler is not invoked. +
    +
    +

    + Example usage: + 

     
+
+  // observer will receive all 4 events (including "default").
+  BehaviorSubject<Object> subject = BehaviorSubject.createDefault("default");
+  subject.subscribe(observer);
+  subject.onNext("one");
+  subject.onNext("two");
+  subject.onNext("three");
+
+  // observer will receive the "one", "two" and "three" events, but not "zero"
+  BehaviorSubject<Object> subject = BehaviorSubject.create();
+  subject.onNext("zero");
+  subject.onNext("one");
+  subject.subscribe(observer);
+  subject.onNext("two");
+  subject.onNext("three");
+
+  // observer will receive only onComplete
+  BehaviorSubject<Object> subject = BehaviorSubject.create();
+  subject.onNext("zero");
+  subject.onNext("one");
+  subject.onComplete();
+  subject.subscribe(observer);
+
+  // observer will receive only onError
+  BehaviorSubject<Object> subject = BehaviorSubject.create();
+  subject.onNext("zero");
+  subject.onNext("one");
+  subject.onError(new RuntimeException("error"));
+  subject.subscribe(observer);
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + + + + + + + + + +
        +
      • +

        subscribeActual

        +
        protected void subscribeActual(Observer<? super T> observer)
        +
        Description copied from class: Observable
        +
        Operator implementations (both source and intermediate) should implement this method that + performs the necessary business logic and handles the incoming Observers. +

        There is no need to call any of the plugin hooks on the current Observable instance or + the Observer; all hooks and basic safeguards have been + applied by Observable.subscribe(Observer) before this method gets called.

        +
        +
        Specified by:
        +
        subscribeActual in class Observable<T>
        +
        Parameters:
        +
        observer - the incoming Observer, never null
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        hasObservers

        +
        @CheckReturnValue
+public boolean hasObservers()
        +
        Description copied from class: Subject
        +
        Returns true if the subject has any Observers. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasObservers in class Subject<T>
        +
        Returns:
        +
        true if the subject has any Observers
        +
        +
        • +
      + + + +
        +
      • +

        getThrowable

        +
        @Nullable
+ @CheckReturnValue
+public @Nullable Throwable getThrowable()
        +
        Description copied from class: Subject
        +
        Returns the error that caused the Subject to terminate or null if the Subject + hasn't terminated yet. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        getThrowable in class Subject<T>
        +
        Returns:
        +
        the error that caused the Subject to terminate or null if the Subject + hasn't terminated yet
        +
        +
        • +
      + + + +
        +
      • +

        getValue

        +
        @Nullable
+ @CheckReturnValue
+public T getValue()
        +
        Returns a single value the Subject currently has or null if no such value exists. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        a single value the Subject currently has or null if no such value exists
        +
        +
        • +
      + + + +
        +
      • +

        hasComplete

        +
        @CheckReturnValue
+public boolean hasComplete()
        +
        Description copied from class: Subject
        +
        Returns true if the subject has reached a terminal state through a complete event. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasComplete in class Subject<T>
        +
        Returns:
        +
        true if the subject has reached a terminal state through a complete event
        +
        See Also:
        +
        Subject.hasThrowable()
        +
        +
        • +
      + + + + + + + +
        +
      • +

        hasValue

        +
        @CheckReturnValue
+public boolean hasValue()
        +
        Returns true if the subject has any value. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        true if the subject has any value
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/CompletableSubject.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/CompletableSubject.html new file mode 100644 index 0000000000..66b40eda3d --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/CompletableSubject.html @@ -0,0 +1,502 @@ + + + + + +CompletableSubject (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.subjects
+

Class CompletableSubject

+
+
+ +
+
    +
  • +
    +
    All Implemented Interfaces:
    +
    CompletableObserver, CompletableSource
    +
    +
    +
    +
    public final class CompletableSubject
+extends Completable
+implements CompletableObserver
    +
    Represents a hot Completable-like source and consumer of events similar to Subjects. +

    + +

    + This subject does not have a public constructor by design; a new non-terminated instance of this + CompletableSubject can be created via the create() method. +

    + Since the CompletableSubject is conceptionally derived from the Processor type in the Reactive Streams specification, + nulls are not allowed (Rule 2.13) + as parameters to onError(Throwable). +

    + Even though CompletableSubject implements the CompletableObserver interface, calling + onSubscribe is not required (Rule 2.12) + if the subject is used as a standalone source. However, calling onSubscribe + after the CompletableSubject reached its terminal state will result in the + given Disposable being disposed immediately. +

    + All methods are thread safe. Calling onComplete() multiple + times has no effect. Calling onError(Throwable) multiple times relays the Throwable to + the RxJavaPlugins.onError(Throwable) global error handler. +

    + This CompletableSubject supports the standard state-peeking methods hasComplete(), + hasThrowable(), getThrowable() and hasObservers(). +

    +
    Scheduler:
    +
    CompletableSubject does not operate by default on a particular Scheduler and + the CompletableObservers get notified on the thread where the terminating onError or onComplete + methods were invoked.
    +
    Error handling:
    +
    When the onError(Throwable) is called, the CompletableSubject enters into a terminal state + and emits the same Throwable instance to the last set of CompletableObservers. During this emission, + if one or more CompletableObservers dispose their respective Disposables, the + Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) (multiple times if multiple CompletableObservers + cancel at once). + If there were no CompletableObservers subscribed to this CompletableSubject when the onError() + was called, the global error handler is not invoked. +
    +
    +

    + Example usage: + 

    
+ CompletableSubject subject = CompletableSubject.create();
+
+ TestObserver<Void> to1 = subject.test();
+
+ // a fresh CompletableSubject is empty
+ to1.assertEmpty();
+
+ subject.onComplete();
+
+ // a CompletableSubject is always void of items
+ to1.assertResult();
+
+ TestObserver<Void> to2 = subject.test()
+
+ // late CompletableObservers receive the terminal event
+ to2.assertResult();
+
    +

    History: 2.0.5 - experimental

    +
    +
    Since:
    +
    2.1
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        onSubscribe

        +
        public void onSubscribe(Disposable d)
        +
        Description copied from interface: CompletableObserver
        +
        Called once by the Completable to set a Disposable on this instance which + then can be used to cancel the subscription at any time.
        +
        +
        Specified by:
        +
        onSubscribe in interface CompletableObserver
        +
        Parameters:
        +
        d - the Disposable instance to call dispose on for cancellation, not null
        +
        +
        • +
      + + + +
        +
      • +

        onError

        +
        public void onError(Throwable e)
        +
        Description copied from interface: CompletableObserver
        +
        Called once if the deferred computation 'throws' an exception.
        +
        +
        Specified by:
        +
        onError in interface CompletableObserver
        +
        Parameters:
        +
        e - the exception, not null.
        +
        +
        • +
      + + + + + + + +
        +
      • +

        subscribeActual

        +
        protected void subscribeActual(CompletableObserver observer)
        +
        Description copied from class: Completable
        +
        Implement this method to handle the incoming CompletableObservers and + perform the business logic in your operator. +

        There is no need to call any of the plugin hooks on the current Completable instance or + the CompletableObserver; all hooks and basic safeguards have been + applied by Completable.subscribe(CompletableObserver) before this method gets called.

        +
        +
        Specified by:
        +
        subscribeActual in class Completable
        +
        Parameters:
        +
        observer - the CompletableObserver instance, never null
        +
        +
        • +
      + + + +
        +
      • +

        getThrowable

        +
        @Nullable
+public @Nullable Throwable getThrowable()
        +
        Returns the terminal error if this CompletableSubject has been terminated with an error, null otherwise.
        +
        +
        Returns:
        +
        the terminal error or null if not terminated or not with an error
        +
        +
        • +
      + + + +
        +
      • +

        hasThrowable

        +
        public boolean hasThrowable()
        +
        Returns true if this CompletableSubject has been terminated with an error.
        +
        +
        Returns:
        +
        true if this CompletableSubject has been terminated with an error
        +
        +
        • +
      + + + +
        +
      • +

        hasComplete

        +
        public boolean hasComplete()
        +
        Returns true if this CompletableSubject has been completed.
        +
        +
        Returns:
        +
        true if this CompletableSubject has been completed
        +
        +
        • +
      + + + +
        +
      • +

        hasObservers

        +
        public boolean hasObservers()
        +
        Returns true if this CompletableSubject has observers.
        +
        +
        Returns:
        +
        true if this CompletableSubject has observers
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/MaybeSubject.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/MaybeSubject.html new file mode 100644 index 0000000000..6421830a2a --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/MaybeSubject.html @@ -0,0 +1,605 @@ + + + + + +MaybeSubject (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.subjects
+

Class MaybeSubject<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type received and emitted
    +
    +
    +
    All Implemented Interfaces:
    +
    MaybeObserver<T>, MaybeSource<T>
    +
    +
    +
    +
    public final class MaybeSubject<T>
+extends Maybe<T>
+implements MaybeObserver<T>
    +
    Represents a hot Maybe-like source and consumer of events similar to Subjects. +

    + +

    + This subject does not have a public constructor by design; a new non-terminated instance of this + MaybeSubject can be created via the create() method. +

    + Since the MaybeSubject is conceptionally derived from the Processor type in the Reactive Streams specification, + nulls are not allowed (Rule 2.13) + as parameters to onSuccess(Object) and onError(Throwable). Such calls will result in a + NullPointerException being thrown and the subject's state is not changed. +

    + Since a MaybeSubject is a Maybe, calling onSuccess, onError + or onComplete will move this MaybeSubject into its terminal state atomically. +

    + All methods are thread safe. Calling onSuccess(Object) or onComplete() multiple + times has no effect. Calling onError(Throwable) multiple times relays the Throwable to + the RxJavaPlugins.onError(Throwable) global error handler. +

    + Even though MaybeSubject implements the MaybeObserver interface, calling + onSubscribe is not required (Rule 2.12) + if the subject is used as a standalone source. However, calling onSubscribe + after the MaybeSubject reached its terminal state will result in the + given Disposable being disposed immediately. +

    + This MaybeSubject supports the standard state-peeking methods hasComplete(), hasThrowable(), + getThrowable() and hasObservers() as well as means to read any success item in a non-blocking + and thread-safe manner via hasValue() and getValue(). +

    + The MaybeSubject does not support clearing its cached onSuccess value. +

    +
    Scheduler:
    +
    MaybeSubject does not operate by default on a particular Scheduler and + the MaybeObservers get notified on the thread where the terminating onSuccess, onError or onComplete + methods were invoked.
    +
    Error handling:
    +
    When the onError(Throwable) is called, the MaybeSubject enters into a terminal state + and emits the same Throwable instance to the last set of MaybeObservers. During this emission, + if one or more MaybeObservers dispose their respective Disposables, the + Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) (multiple times if multiple MaybeObservers + cancel at once). + If there were no MaybeObservers subscribed to this MaybeSubject when the onError() + was called, the global error handler is not invoked. +
    +
    +

    + Example usage: + 

    
+ MaybeSubject<Integer> subject1 = MaybeSubject.create();
+
+ TestObserver<Integer> to1 = subject1.test();
+
+ // MaybeSubjects are empty by default
+ to1.assertEmpty();
+
+ subject1.onSuccess(1);
+
+ // onSuccess is a terminal event with MaybeSubjects
+ // TestObserver converts onSuccess into onNext + onComplete
+ to1.assertResult(1);
+
+ TestObserver<Integer> to2 = subject1.test();
+
+ // late Observers receive the terminal signal (onSuccess) too
+ to2.assertResult(1);
+
+ // -----------------------------------------------------
+
+ MaybeSubject<Integer> subject2 = MaybeSubject.create();
+
+ TestObserver<Integer> to3 = subject2.test();
+
+ subject2.onComplete();
+
+ // a completed MaybeSubject completes its MaybeObservers
+ to3.assertResult();
+
+ TestObserver<Integer> to4 = subject1.test();
+
+ // late Observers receive the terminal signal (onComplete) too
+ to4.assertResult();
+
    +

    History: 2.0.5 - experimental

    +
    +
    Since:
    +
    2.1
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull MaybeSubject<T> create()
        +
        Creates a fresh MaybeSubject.
        +
        +
        Type Parameters:
        +
        T - the value type received and emitted
        +
        Returns:
        +
        the new MaybeSubject instance
        +
        +
        • +
      + + + +
        +
      • +

        onSubscribe

        +
        public void onSubscribe(Disposable d)
        +
        Description copied from interface: MaybeObserver
        +
        Provides the MaybeObserver with the means of cancelling (disposing) the + connection (channel) with the Maybe in both + synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.
        +
        +
        Specified by:
        +
        onSubscribe in interface MaybeObserver<T>
        +
        Parameters:
        +
        d - the Disposable instance whose Disposable.dispose() can + be called anytime to cancel the connection
        +
        +
        • +
      + + + + + + + + + + + + + +
        +
      • +

        onComplete

        +
        public void onComplete()
        +
        Description copied from interface: MaybeObserver
        +
        Called once the deferred computation completes normally.
        +
        +
        Specified by:
        +
        onComplete in interface MaybeObserver<T>
        +
        +
        • +
      + + + +
        +
      • +

        subscribeActual

        +
        protected void subscribeActual(MaybeObserver<? super T> observer)
        +
        Description copied from class: Maybe
        +
        Implement this method in subclasses to handle the incoming MaybeObservers. +

        There is no need to call any of the plugin hooks on the current Maybe instance or + the MaybeObserver; all hooks and basic safeguards have been + applied by Maybe.subscribe(MaybeObserver) before this method gets called.

        +
        +
        Specified by:
        +
        subscribeActual in class Maybe<T>
        +
        Parameters:
        +
        observer - the MaybeObserver to handle, not null
        +
        +
        • +
      + + + +
        +
      • +

        getValue

        +
        @Nullable
+public T getValue()
        +
        Returns the success value if this MaybeSubject was terminated with a success value.
        +
        +
        Returns:
        +
        the success value or null
        +
        +
        • +
      + + + +
        +
      • +

        hasValue

        +
        public boolean hasValue()
        +
        Returns true if this MaybeSubject was terminated with a success value.
        +
        +
        Returns:
        +
        true if this MaybeSubject was terminated with a success value
        +
        +
        • +
      + + + +
        +
      • +

        getThrowable

        +
        @Nullable
+public @Nullable Throwable getThrowable()
        +
        Returns the terminal error if this MaybeSubject has been terminated with an error, null otherwise.
        +
        +
        Returns:
        +
        the terminal error or null if not terminated or not with an error
        +
        +
        • +
      + + + +
        +
      • +

        hasThrowable

        +
        public boolean hasThrowable()
        +
        Returns true if this MaybeSubject has been terminated with an error.
        +
        +
        Returns:
        +
        true if this MaybeSubject has been terminated with an error
        +
        +
        • +
      + + + +
        +
      • +

        hasComplete

        +
        public boolean hasComplete()
        +
        Returns true if this MaybeSubject has been completed.
        +
        +
        Returns:
        +
        true if this MaybeSubject has been completed
        +
        +
        • +
      + + + +
        +
      • +

        hasObservers

        +
        public boolean hasObservers()
        +
        Returns true if this MaybeSubject has observers.
        +
        +
        Returns:
        +
        true if this MaybeSubject has observers
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/PublishSubject.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/PublishSubject.html new file mode 100644 index 0000000000..61763357d6 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/PublishSubject.html @@ -0,0 +1,578 @@ + + + + + +PublishSubject (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.subjects
+

Class PublishSubject<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the type of items observed and emitted by the Subject
    +
    +
    +
    All Implemented Interfaces:
    +
    ObservableSource<T>, Observer<T>
    +
    +
    +
    +
    public final class PublishSubject<T>
+extends Subject<T>
    +
    A Subject that emits (multicasts) items to currently subscribed Observers and terminal events to current + or late Observers. +

    + +

    + This subject does not have a public constructor by design; a new empty instance of this + PublishSubject can be created via the create() method. +

    + Since a Subject is conceptionally derived from the Processor type in the Reactive Streams specification, + nulls are not allowed (Rule 2.13) as + parameters to onNext(Object) and onError(Throwable). Such calls will result in a + NullPointerException being thrown and the subject's state is not changed. +

    + Since a PublishSubject is an Observable, it does not support backpressure. +

    + When this PublishSubject is terminated via onError(Throwable) or onComplete(), + late Observers only receive the respective terminal event. +

    + Unlike a BehaviorSubject, a PublishSubject doesn't retain/cache items, therefore, a new + Observer won't receive any past items. +

    + Even though PublishSubject implements the Observer interface, calling + onSubscribe is not required (Rule 2.12) + if the subject is used as a standalone source. However, calling onSubscribe + after the PublishSubject reached its terminal state will result in the + given Disposable being disposed immediately. +

    + Calling onNext(Object), onError(Throwable) and onComplete() + is required to be serialized (called from the same thread or called non-overlappingly from different threads + through external means of serialization). The Subject.toSerialized() method available to all Subjects + provides such serialization and also protects against reentrance (i.e., when a downstream Observer + consuming this subject also wants to call onNext(Object) on this subject recursively). +

    + This PublishSubject supports the standard state-peeking methods hasComplete(), hasThrowable(), + getThrowable() and hasObservers(). +

    +
    Scheduler:
    +
    PublishSubject does not operate by default on a particular Scheduler and + the Observers get notified on the thread the respective onXXX methods were invoked.
    +
    Error handling:
    +
    When the onError(Throwable) is called, the PublishSubject enters into a terminal state + and emits the same Throwable instance to the last set of Observers. During this emission, + if one or more Observers dispose their respective Disposables, the + Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) (multiple times if multiple Observers + cancel at once). + If there were no Observers subscribed to this PublishSubject when the onError() + was called, the global error handler is not invoked. +
    +
    +

    + Example usage: + 

     
+
+  PublishSubject<Object> subject = PublishSubject.create();
+  // observer1 will receive all onNext and onComplete events
+  subject.subscribe(observer1);
+  subject.onNext("one");
+  subject.onNext("two");
+  // observer2 will only receive "three" and onComplete
+  subject.subscribe(observer2);
+  subject.onNext("three");
+  subject.onComplete();
+
+  // late Observers only receive the terminal event
+  subject.test().assertEmpty();
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        subscribeActual

        +
        protected void subscribeActual(Observer<? super T> t)
        +
        Description copied from class: Observable
        +
        Operator implementations (both source and intermediate) should implement this method that + performs the necessary business logic and handles the incoming Observers. +

        There is no need to call any of the plugin hooks on the current Observable instance or + the Observer; all hooks and basic safeguards have been + applied by Observable.subscribe(Observer) before this method gets called.

        +
        +
        Specified by:
        +
        subscribeActual in class Observable<T>
        +
        Parameters:
        +
        t - the incoming Observer, never null
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        hasObservers

        +
        @CheckReturnValue
+public boolean hasObservers()
        +
        Description copied from class: Subject
        +
        Returns true if the subject has any Observers. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasObservers in class Subject<T>
        +
        Returns:
        +
        true if the subject has any Observers
        +
        +
        • +
      + + + +
        +
      • +

        getThrowable

        +
        @Nullable
+ @CheckReturnValue
+public @Nullable Throwable getThrowable()
        +
        Description copied from class: Subject
        +
        Returns the error that caused the Subject to terminate or null if the Subject + hasn't terminated yet. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        getThrowable in class Subject<T>
        +
        Returns:
        +
        the error that caused the Subject to terminate or null if the Subject + hasn't terminated yet
        +
        +
        • +
      + + + + + + + +
        +
      • +

        hasComplete

        +
        @CheckReturnValue
+public boolean hasComplete()
        +
        Description copied from class: Subject
        +
        Returns true if the subject has reached a terminal state through a complete event. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasComplete in class Subject<T>
        +
        Returns:
        +
        true if the subject has reached a terminal state through a complete event
        +
        See Also:
        +
        Subject.hasThrowable()
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/ReplaySubject.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/ReplaySubject.html new file mode 100644 index 0000000000..4e2a149a7f --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/ReplaySubject.html @@ -0,0 +1,928 @@ + + + + + +ReplaySubject (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.subjects
+

Class ReplaySubject<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    All Implemented Interfaces:
    +
    ObservableSource<T>, Observer<T>
    +
    +
    +
    +
    public final class ReplaySubject<T>
+extends Subject<T>
    +
    Replays events (in a configurable bounded or unbounded manner) to current and late Observers. +

    + This subject does not have a public constructor by design; a new empty instance of this + ReplaySubject can be created via the following create methods that + allow specifying the retention policy for items: +

      +
    • create() - creates an empty, unbounded ReplaySubject that + caches all items and the terminal event it receives. +

      + +

      + +

      • +
    • create(int) - creates an empty, unbounded ReplaySubject + with a hint about how many total items one expects to retain. +
      • +
    • createWithSize(int) - creates an empty, size-bound ReplaySubject + that retains at most the given number of the latest item it receives. +

      + +

      • +
    • createWithTime(long, TimeUnit, Scheduler) - creates an empty, time-bound + ReplaySubject that retains items no older than the specified time amount. +

      + +

      • +
    • createWithTimeAndSize(long, TimeUnit, Scheduler, int) - creates an empty, + time- and size-bound ReplaySubject that retains at most the given number + items that are also not older than the specified time amount. +

      + +

      • +
    +

    + Since a Subject is conceptionally derived from the Processor type in the Reactive Streams specification, + nulls are not allowed (Rule 2.13) as + parameters to onNext(Object) and onError(Throwable). Such calls will result in a + NullPointerException being thrown and the subject's state is not changed. +

    + Since a ReplaySubject is an Observable, it does not support backpressure. +

    + When this ReplaySubject is terminated via onError(Throwable) or onComplete(), + late Observers will receive the retained/cached items first (if any) followed by the respective + terminal event. If the ReplaySubject has a time-bound, the age of the retained/cached items are still considered + when replaying and thus it may result in no items being emitted before the terminal event. +

    + Once an Observer has subscribed, it will receive items continuously from that point on. Bounds only affect how + many past items a new Observer will receive before it catches up with the live event feed. +

    + Even though ReplaySubject implements the Observer interface, calling + onSubscribe is not required (Rule 2.12) + if the subject is used as a standalone source. However, calling onSubscribe + after the ReplaySubject reached its terminal state will result in the + given Disposable being disposed immediately. +

    + Calling onNext(Object), onError(Throwable) and onComplete() + is required to be serialized (called from the same thread or called non-overlappingly from different threads + through external means of serialization). The Subject.toSerialized() method available to all Subjects + provides such serialization and also protects against reentrance (i.e., when a downstream Observer + consuming this subject also wants to call onNext(Object) on this subject recursively). +

    + This ReplaySubject supports the standard state-peeking methods hasComplete(), hasThrowable(), + getThrowable() and hasObservers() as well as means to read the retained/cached items + in a non-blocking and thread-safe manner via hasValue(), getValue(), + getValues() or getValues(Object[]). +

    + Note that due to concurrency requirements, a size- and time-bounded ReplaySubject may hold strong references to more + source emissions than specified while it isn't terminated yet. Use the cleanupBuffer() to allow + such inaccessible items to be cleaned up by GC once no consumer references it anymore. +

    +
    Scheduler:
    +
    ReplaySubject does not operate by default on a particular Scheduler and + the Observers get notified on the thread the respective onXXX methods were invoked. + Time-bound ReplaySubjects use the given Scheduler in their create methods + as time source to timestamp of items received for the age checks.
    +
    Error handling:
    +
    When the onError(Throwable) is called, the ReplaySubject enters into a terminal state + and emits the same Throwable instance to the last set of Observers. During this emission, + if one or more Observers dispose their respective Disposables, the + Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) (multiple times if multiple Observers + cancel at once). + If there were no Observers subscribed to this ReplaySubject when the onError() + was called, the global error handler is not invoked. +
    +
    +

    + Example usage: + 

     
+
+  ReplaySubject<Object> subject = ReplaySubject.create();
+  subject.onNext("one");
+  subject.onNext("two");
+  subject.onNext("three");
+  subject.onComplete();
+
+  // both of the following will get the onNext/onComplete calls from above
+  subject.subscribe(observer1);
+  subject.subscribe(observer2);
+
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull ReplaySubject<T> create()
        +
        Creates an unbounded replay subject. +

        + The internal buffer is backed by an ArrayList and starts with an initial capacity of 16. Once the + number of items reaches this capacity, it will grow as necessary (usually by 50%). However, as the + number of items grows, this causes frequent array reallocation and copying, and may hurt performance + and latency. This can be avoided with the create(int) overload which takes an initial capacity + parameter and can be tuned to reduce the array reallocation frequency as needed.

        +
        +
        Type Parameters:
        +
        T - the type of items observed and emitted by the Subject
        +
        Returns:
        +
        the created subject
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull ReplaySubject<T> create(int capacityHint)
        +
        Creates an unbounded replay subject with the specified initial buffer capacity. +

        + Use this method to avoid excessive array reallocation while the internal buffer grows to accommodate new + items. For example, if you know that the buffer will hold 32k items, you can ask the + ReplaySubject to preallocate its internal array with a capacity to hold that many items. Once + the items start to arrive, the internal array won't need to grow, creating less garbage and no overhead + due to frequent array-copying.

        +
        +
        Type Parameters:
        +
        T - the type of items observed and emitted by the Subject
        +
        Parameters:
        +
        capacityHint - the initial buffer capacity
        +
        Returns:
        +
        the created subject
        +
        Throws:
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        createWithSize

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull ReplaySubject<T> createWithSize(int maxSize)
        +
        Creates a size-bounded replay subject. +

        + In this setting, the ReplaySubject holds at most size items in its internal buffer and + discards the oldest item. +

        + When observers subscribe to a terminated ReplaySubject, they are guaranteed to see at most + size onNext events followed by a termination event. +

        + If an observer subscribes while the ReplaySubject is active, it will observe all items in the + buffer at that point in time and each item observed afterwards, even if the buffer evicts items due to + the size constraint in the mean time. In other words, once an Observer subscribes, it will receive items + without gaps in the sequence.

        +
        +
        Type Parameters:
        +
        T - the type of items observed and emitted by the Subject
        +
        Parameters:
        +
        maxSize - the maximum number of buffered items
        +
        Returns:
        +
        the created subject
        +
        Throws:
        +
        IllegalArgumentException - if maxSize is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        createWithTime

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull ReplaySubject<T> createWithTime(long maxAge,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler)
        +
        Creates a time-bounded replay subject. +

        + In this setting, the ReplaySubject internally tags each observed item with a timestamp value + supplied by the Scheduler and keeps only those whose age is less than the supplied time value + converted to milliseconds. For example, an item arrives at T=0 and the max age is set to 5; at T>=5 + this first item is then evicted by any subsequent item or termination event, leaving the buffer empty. +

        + Once the subject is terminated, observers subscribing to it will receive items that remained in the + buffer after the terminal event, regardless of their age. +

        + If an observer subscribes while the ReplaySubject is active, it will observe only those items + from within the buffer that have an age less than the specified time, and each item observed thereafter, + even if the buffer evicts items due to the time constraint in the mean time. In other words, once an + observer subscribes, it observes items without gaps in the sequence except for any outdated items at the + beginning of the sequence. +

        + Note that terminal notifications (onError and onComplete) trigger eviction as well. For + example, with a max age of 5, the first item is observed at T=0, then an onComplete notification + arrives at T=10. If an observer subscribes at T=11, it will find an empty ReplaySubject with just + an onComplete notification.

        +
        +
        Type Parameters:
        +
        T - the type of items observed and emitted by the Subject
        +
        Parameters:
        +
        maxAge - the maximum age of the contained items
        +
        unit - the time unit of time
        +
        scheduler - the Scheduler that provides the current time
        +
        Returns:
        +
        the created subject
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if maxAge is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        createWithTimeAndSize

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull ReplaySubject<T> createWithTimeAndSize(long maxAge,
+        @NonNull TimeUnit unit,
+        @NonNull Scheduler scheduler,
+        int maxSize)
        +
        Creates a time- and size-bounded replay subject. +

        + In this setting, the ReplaySubject internally tags each received item with a timestamp value + supplied by the Scheduler and holds at most size items in its internal buffer. It evicts + items from the start of the buffer if their age becomes less-than or equal to the supplied age in + milliseconds or the buffer reaches its size limit. +

        + When observers subscribe to a terminated ReplaySubject, they observe the items that remained in + the buffer after the terminal notification, regardless of their age, but at most size items. +

        + If an observer subscribes while the ReplaySubject is active, it will observe only those items + from within the buffer that have age less than the specified time and each subsequent item, even if the + buffer evicts items due to the time constraint in the mean time. In other words, once an observer + subscribes, it observes items without gaps in the sequence except for the outdated items at the beginning + of the sequence. +

        + Note that terminal notifications (onError and onComplete) trigger eviction as well. For + example, with a max age of 5, the first item is observed at T=0, then an onComplete notification + arrives at T=10. If an observer subscribes at T=11, it will find an empty ReplaySubject with just + an onComplete notification.

        +
        +
        Type Parameters:
        +
        T - the type of items observed and emitted by the Subject
        +
        Parameters:
        +
        maxAge - the maximum age of the contained items
        +
        unit - the time unit of time
        +
        maxSize - the maximum number of buffered items
        +
        scheduler - the Scheduler that provides the current time
        +
        Returns:
        +
        the created subject
        +
        Throws:
        +
        NullPointerException - if unit or scheduler is null
        +
        IllegalArgumentException - if maxAge or maxSize is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        subscribeActual

        +
        protected void subscribeActual(Observer<? super T> observer)
        +
        Description copied from class: Observable
        +
        Operator implementations (both source and intermediate) should implement this method that + performs the necessary business logic and handles the incoming Observers. +

        There is no need to call any of the plugin hooks on the current Observable instance or + the Observer; all hooks and basic safeguards have been + applied by Observable.subscribe(Observer) before this method gets called.

        +
        +
        Specified by:
        +
        subscribeActual in class Observable<T>
        +
        Parameters:
        +
        observer - the incoming Observer, never null
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        hasObservers

        +
        @CheckReturnValue
+public boolean hasObservers()
        +
        Description copied from class: Subject
        +
        Returns true if the subject has any Observers. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasObservers in class Subject<T>
        +
        Returns:
        +
        true if the subject has any Observers
        +
        +
        • +
      + + + +
        +
      • +

        getThrowable

        +
        @Nullable
+ @CheckReturnValue
+public @Nullable Throwable getThrowable()
        +
        Description copied from class: Subject
        +
        Returns the error that caused the Subject to terminate or null if the Subject + hasn't terminated yet. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        getThrowable in class Subject<T>
        +
        Returns:
        +
        the error that caused the Subject to terminate or null if the Subject + hasn't terminated yet
        +
        +
        • +
      + + + +
        +
      • +

        getValue

        +
        @Nullable
+ @CheckReturnValue
+public T getValue()
        +
        Returns a single value the Subject currently has or null if no such value exists. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        a single value the Subject currently has or null if no such value exists
        +
        +
        • +
      + + + +
        +
      • +

        cleanupBuffer

        +
        public void cleanupBuffer()
        +
        Makes sure the item cached by the head node in a bounded + ReplaySubject is released (as it is never part of a replay). +

        + By default, live bounded buffers will remember one item before + the currently receivable one to ensure subscribers can always + receive a continuous sequence of items. A terminated ReplaySubject + automatically releases this inaccessible item. +

        + The method must be called sequentially, similar to the standard + onXXX methods. +

        History: 2.1.11 - experimental

        +
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        getValues

        +
        @CheckReturnValue
+public Object[] getValues()
        +
        Returns an Object array containing snapshot all values of the Subject. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        the array containing the snapshot of all values of the Subject
        +
        +
        • +
      + + + + + +
        +
      • +

        getValues

        +
        @CheckReturnValue
+public T[] getValues(T[] array)
        +
        Returns a typed array containing a snapshot of all values of the Subject. +

        The method follows the conventions of Collection.toArray by setting the array element + after the last value to null (if the capacity permits). +

        The method is thread-safe.

        +
        +
        Parameters:
        +
        array - the target array to copy values into if it fits
        +
        Returns:
        +
        the given array if the values fit into it or a new array containing all values
        +
        +
        • +
      + + + +
        +
      • +

        hasComplete

        +
        @CheckReturnValue
+public boolean hasComplete()
        +
        Description copied from class: Subject
        +
        Returns true if the subject has reached a terminal state through a complete event. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasComplete in class Subject<T>
        +
        Returns:
        +
        true if the subject has reached a terminal state through a complete event
        +
        See Also:
        +
        Subject.hasThrowable()
        +
        +
        • +
      + + + + + + + +
        +
      • +

        hasValue

        +
        @CheckReturnValue
+public boolean hasValue()
        +
        Returns true if the subject has any value. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        true if the subject has any value
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/SingleSubject.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/SingleSubject.html new file mode 100644 index 0000000000..e7cb5c18cd --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/SingleSubject.html @@ -0,0 +1,552 @@ + + + + + +SingleSubject (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.subjects
+

Class SingleSubject<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type received and emitted
    +
    +
    +
    All Implemented Interfaces:
    +
    SingleObserver<T>, SingleSource<T>
    +
    +
    +
    +
    public final class SingleSubject<T>
+extends Single<T>
+implements SingleObserver<T>
    +
    Represents a hot Single-like source and consumer of events similar to Subjects. +

    + +

    + This subject does not have a public constructor by design; a new non-terminated instance of this + SingleSubject can be created via the create() method. +

    + Since the SingleSubject is conceptionally derived from the Processor type in the Reactive Streams specification, + nulls are not allowed (Rule 2.13) + as parameters to onSuccess(Object) and onError(Throwable). Such calls will result in a + NullPointerException being thrown and the subject's state is not changed. +

    + Since a SingleSubject is a Single, calling onSuccess or onError + will move this SingleSubject into its terminal state atomically. +

    + All methods are thread safe. Calling onSuccess(Object) multiple + times has no effect. Calling onError(Throwable) multiple times relays the Throwable to + the RxJavaPlugins.onError(Throwable) global error handler. +

    + Even though SingleSubject implements the SingleObserver interface, calling + onSubscribe is not required (Rule 2.12) + if the subject is used as a standalone source. However, calling onSubscribe + after the SingleSubject reached its terminal state will result in the + given Disposable being disposed immediately. +

    + This SingleSubject supports the standard state-peeking methods hasThrowable(), + getThrowable() and hasObservers() as well as means to read any success item in a non-blocking + and thread-safe manner via hasValue() and getValue(). +

    + The SingleSubject does not support clearing its cached onSuccess value. +

    +
    Scheduler:
    +
    SingleSubject does not operate by default on a particular Scheduler and + the SingleObservers get notified on the thread where the terminating onSuccess or onError + methods were invoked.
    +
    Error handling:
    +
    When the onError(Throwable) is called, the SingleSubject enters into a terminal state + and emits the same Throwable instance to the last set of SingleObservers. During this emission, + if one or more SingleObservers dispose their respective Disposables, the + Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable) (multiple times if multiple SingleObservers + cancel at once). + If there were no SingleObservers subscribed to this SingleSubject when the onError() + was called, the global error handler is not invoked. +
    +
    +

    + Example usage: + 

    
+ SingleSubject<Integer> subject1 = SingleSubject.create();
+ 
+ TestObserver<Integer> to1 = subject1.test();
+ 
+ // SingleSubjects are empty by default
+ to1.assertEmpty();
+ 
+ subject1.onSuccess(1);
+ 
+ // onSuccess is a terminal event with SingleSubjects
+ // TestObserver converts onSuccess into onNext + onComplete
+ to1.assertResult(1);
+
+ TestObserver<Integer> to2 = subject1.test();
+ 
+ // late Observers receive the terminal signal (onSuccess) too
+ to2.assertResult(1);
+
    +

    History: 2.0.5 - experimental

    +
    +
    Since:
    +
    2.1
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull SingleSubject<T> create()
        +
        Creates a fresh SingleSubject.
        +
        +
        Type Parameters:
        +
        T - the value type received and emitted
        +
        Returns:
        +
        the new SingleSubject instance
        +
        +
        • +
      + + + +
        +
      • +

        onSubscribe

        +
        public void onSubscribe(@NonNull
+                        @NonNull Disposable d)
        +
        Description copied from interface: SingleObserver
        +
        Provides the SingleObserver with the means of cancelling (disposing) the + connection (channel) with the Single in both + synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.
        +
        +
        Specified by:
        +
        onSubscribe in interface SingleObserver<T>
        +
        Parameters:
        +
        d - the Disposable instance whose Disposable.dispose() can + be called anytime to cancel the connection
        +
        +
        • +
      + + + + + + + + + + + + + +
        +
      • +

        subscribeActual

        +
        protected void subscribeActual(@NonNull
+                               @NonNull SingleObserver<? super T> observer)
        +
        Description copied from class: Single
        +
        Implement this method in subclasses to handle the incoming SingleObservers. +

        There is no need to call any of the plugin hooks on the current Single instance or + the SingleObserver; all hooks and basic safeguards have been + applied by Single.subscribe(SingleObserver) before this method gets called.

        +
        +
        Specified by:
        +
        subscribeActual in class Single<T>
        +
        Parameters:
        +
        observer - the SingleObserver to handle, not null
        +
        +
        • +
      + + + +
        +
      • +

        getValue

        +
        @Nullable
+public T getValue()
        +
        Returns the success value if this SingleSubject was terminated with a success value.
        +
        +
        Returns:
        +
        the success value or null
        +
        +
        • +
      + + + +
        +
      • +

        hasValue

        +
        public boolean hasValue()
        +
        Returns true if this SingleSubject was terminated with a success value.
        +
        +
        Returns:
        +
        true if this SingleSubject was terminated with a success value
        +
        +
        • +
      + + + +
        +
      • +

        getThrowable

        +
        @Nullable
+public @Nullable Throwable getThrowable()
        +
        Returns the terminal error if this SingleSubject has been terminated with an error, null otherwise.
        +
        +
        Returns:
        +
        the terminal error or null if not terminated or not with an error
        +
        +
        • +
      + + + +
        +
      • +

        hasThrowable

        +
        public boolean hasThrowable()
        +
        Returns true if this SingleSubject has been terminated with an error.
        +
        +
        Returns:
        +
        true if this SingleSubject has been terminated with an error
        +
        +
        • +
      + + + +
        +
      • +

        hasObservers

        +
        public boolean hasObservers()
        +
        Returns true if this SingleSubject has observers.
        +
        +
        Returns:
        +
        true if this SingleSubject has observers
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/Subject.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/Subject.html new file mode 100644 index 0000000000..a22882b5f5 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/Subject.html @@ -0,0 +1,415 @@ + + + + + +Subject (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.subjects
+

Class Subject<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Subject

        +
        public Subject()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        hasObservers

        +
        @CheckReturnValue
+public abstract boolean hasObservers()
        +
        Returns true if the subject has any Observers. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        true if the subject has any Observers
        +
        +
        • +
      + + + +
        +
      • +

        hasThrowable

        +
        @CheckReturnValue
+public abstract boolean hasThrowable()
        +
        Returns true if the subject has reached a terminal state through an error event. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        true if the subject has reached a terminal state through an error event
        +
        See Also:
        +
        getThrowable(), +hasComplete()
        +
        +
        • +
      + + + +
        +
      • +

        hasComplete

        +
        @CheckReturnValue
+public abstract boolean hasComplete()
        +
        Returns true if the subject has reached a terminal state through a complete event. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        true if the subject has reached a terminal state through a complete event
        +
        See Also:
        +
        hasThrowable()
        +
        +
        • +
      + + + +
        +
      • +

        getThrowable

        +
        @Nullable
+ @CheckReturnValue
+public abstract @Nullable Throwable getThrowable()
        +
        Returns the error that caused the Subject to terminate or null if the Subject + hasn't terminated yet. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        the error that caused the Subject to terminate or null if the Subject + hasn't terminated yet
        +
        +
        • +
      + + + +
        +
      • +

        toSerialized

        +
        @NonNull
+ @CheckReturnValue
+public final @NonNull Subject<T> toSerialized()
        +
        Wraps this Subject and serializes the calls to the onSubscribe, onNext, onError and + onComplete methods, making them thread-safe. +

        The method is thread-safe.

        +
        +
        Returns:
        +
        the wrapped and serialized subject
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/UnicastSubject.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/UnicastSubject.html new file mode 100644 index 0000000000..27a2f9c68f --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/UnicastSubject.html @@ -0,0 +1,768 @@ + + + + + +UnicastSubject (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + +
+
io.reactivex.rxjava3.subjects
+

Class UnicastSubject<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type received and emitted by this Subject subclass
    +
    +
    +
    All Implemented Interfaces:
    +
    ObservableSource<T>, Observer<T>
    +
    +
    +
    +
    public final class UnicastSubject<T>
+extends Subject<T>
    +
    A Subject that queues up events until a single Observer subscribes to it, replays + those events to it until the Observer catches up and then switches to relaying events live to + this single Observer until this UnicastSubject terminates or the Observer disposes. +

    + +

    + Note that UnicastSubject holds an unbounded internal buffer. +

    + This subject does not have a public constructor by design; a new empty instance of this + UnicastSubject can be created via the following create methods that + allow specifying the retention policy for items: +

      +
    • create() - creates an empty, unbounded UnicastSubject that + caches all items and the terminal event it receives.
      • +
    • create(int) - creates an empty, unbounded UnicastSubject + with a hint about how many total items one expects to retain.
      • +
    • create(boolean) - creates an empty, unbounded UnicastSubject that + optionally delays an error it receives and replays it after the regular items have been emitted.
      • +
    • create(int, Runnable) - creates an empty, unbounded UnicastSubject + with a hint about how many total items one expects to retain and a callback that will be + called exactly once when the UnicastSubject gets terminated or the single Observer disposes.
      • +
    • create(int, Runnable, boolean) - creates an empty, unbounded UnicastSubject + with a hint about how many total items one expects to retain and a callback that will be + called exactly once when the UnicastSubject gets terminated or the single Observer disposes + and optionally delays an error it receives and replays it after the regular items have been emitted.
      • +
    +

    + If more than one Observer attempts to subscribe to this UnicastSubject, they + will receive an IllegalStateException indicating the single-use-only nature of this UnicastSubject, + even if the UnicastSubject already terminated with an error. +

    + Since a Subject is conceptionally derived from the Processor type in the Reactive Streams specification, + nulls are not allowed (Rule 2.13) as + parameters to onNext(Object) and onError(Throwable). Such calls will result in a + NullPointerException being thrown and the subject's state is not changed. +

    + Since a UnicastSubject is an Observable, it does not support backpressure. +

    + When this UnicastSubject is terminated via onError(Throwable) the current or late single Observer + may receive the Throwable before any available items could be emitted. To make sure an onError event is delivered + to the Observer after the normal items, create a UnicastSubject with the create(boolean) or + create(int, Runnable, boolean) factory methods. +

    + Even though UnicastSubject implements the Observer interface, calling + onSubscribe is not required (Rule 2.12) + if the subject is used as a standalone source. However, calling onSubscribe + after the UnicastSubject reached its terminal state will result in the + given Disposable being disposed immediately. +

    + Calling onNext(Object), onError(Throwable) and onComplete() + is required to be serialized (called from the same thread or called non-overlappingly from different threads + through external means of serialization). The Subject.toSerialized() method available to all Subjects + provides such serialization and also protects against reentrance (i.e., when a downstream Observer + consuming this subject also wants to call onNext(Object) on this subject recursively). +

    + This UnicastSubject supports the standard state-peeking methods hasComplete(), hasThrowable(), + getThrowable() and hasObservers(). +

    +
    Scheduler:
    +
    UnicastSubject does not operate by default on a particular Scheduler and + the single Observer gets notified on the thread the respective onXXX methods were invoked.
    +
    Error handling:
    +
    When the onError(Throwable) is called, the UnicastSubject enters into a terminal state + and emits the same Throwable instance to the current single Observer. During this emission, + if the single Observers disposes its respective Disposable, the + Throwable is delivered to the global error handler via + RxJavaPlugins.onError(Throwable). + If there were no Observers subscribed to this UnicastSubject when the onError() + was called, the global error handler is not invoked. +
    +
    +

    + Example usage: + 

    
+ UnicastSubject<Integer> subject = UnicastSubject.create();
+
+ TestObserver<Integer> to1 = subject.test();
+
+ // fresh UnicastSubjects are empty
+ to1.assertEmpty();
+
+ TestObserver<Integer> to2 = subject.test();
+
+ // A UnicastSubject only allows one Observer during its lifetime
+ to2.assertFailure(IllegalStateException.class);
+
+ subject.onNext(1);
+ to1.assertValue(1);
+
+ subject.onNext(2);
+ to1.assertValues(1, 2);
+
+ subject.onComplete();
+ to1.assertResult(1, 2);
+
+ // ----------------------------------------------------
+
+ UnicastSubject<Integer> subject2 = UnicastSubject.create();
+
+ // a UnicastSubject caches events until its single Observer subscribes
+ subject2.onNext(1);
+ subject2.onNext(2);
+ subject2.onComplete();
+
+ TestObserver<Integer> to3 = subject2.test();
+
+ // the cached events are emitted in order
+ to3.assertResult(1, 2);
+
    +
    +
    Since:
    +
    2.0
    +
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull UnicastSubject<T> create()
        +
        Creates an UnicastSubject with an internal buffer capacity hint 16.
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Returns:
        +
        an UnicastSubject instance
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull UnicastSubject<T> create(int capacityHint)
        +
        Creates an UnicastSubject with the given internal buffer capacity hint.
        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        capacityHint - the hint to size the internal unbounded buffer
        +
        Returns:
        +
        an UnicastSubject instance
        +
        Throws:
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull UnicastSubject<T> create(int capacityHint,
+        @NonNull Runnable onTerminate)
        +
        Creates an UnicastSubject with the given internal buffer capacity hint and a callback for + the case when the single Subscriber cancels its subscription + or the subject is terminated. + +

        The callback, if not null, is called exactly once and + non-overlapped with any active replay.

        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        capacityHint - the hint to size the internal unbounded buffer
        +
        onTerminate - the callback to run when the Subject is terminated or cancelled, null not allowed
        +
        Returns:
        +
        an UnicastSubject instance
        +
        Throws:
        +
        NullPointerException - if onTerminate is null
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull UnicastSubject<T> create(int capacityHint,
+        @NonNull Runnable onTerminate,
+        boolean delayError)
        +
        Creates an UnicastSubject with the given internal buffer capacity hint, delay error flag and + a callback for the case when the single Observer disposes its Disposable + or the subject is terminated. + +

        The callback, if not null, is called exactly once and + non-overlapped with any active replay. +

        History: 2.0.8 - experimental

        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        capacityHint - the hint to size the internal unbounded buffer
        +
        onTerminate - the callback to run when the Subject is terminated or cancelled, null not allowed
        +
        delayError - deliver pending onNext events before onError
        +
        Returns:
        +
        an UnicastSubject instance
        +
        Throws:
        +
        NullPointerException - if onTerminate is null
        +
        IllegalArgumentException - if capacityHint is non-positive
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        create

        +
        @CheckReturnValue
+ @NonNull
+public static <T> @NonNull UnicastSubject<T> create(boolean delayError)
        +
        Creates an UnicastSubject with an internal buffer capacity hint 16 and given delay error flag. + +

        The callback, if not null, is called exactly once and + non-overlapped with any active replay. +

        History: 2.0.8 - experimental

        +
        +
        Type Parameters:
        +
        T - the value type
        +
        Parameters:
        +
        delayError - deliver pending onNext events before onError
        +
        Returns:
        +
        an UnicastSubject instance
        +
        Since:
        +
        2.2
        +
        +
        • +
      + + + +
        +
      • +

        subscribeActual

        +
        protected void subscribeActual(Observer<? super T> observer)
        +
        Description copied from class: Observable
        +
        Operator implementations (both source and intermediate) should implement this method that + performs the necessary business logic and handles the incoming Observers. +

        There is no need to call any of the plugin hooks on the current Observable instance or + the Observer; all hooks and basic safeguards have been + applied by Observable.subscribe(Observer) before this method gets called.

        +
        +
        Specified by:
        +
        subscribeActual in class Observable<T>
        +
        Parameters:
        +
        observer - the incoming Observer, never null
        +
        +
        • +
      + + + + + + + + + + + + + + + + + + + + + +
        +
      • +

        hasObservers

        +
        @CheckReturnValue
+public boolean hasObservers()
        +
        Description copied from class: Subject
        +
        Returns true if the subject has any Observers. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasObservers in class Subject<T>
        +
        Returns:
        +
        true if the subject has any Observers
        +
        +
        • +
      + + + +
        +
      • +

        getThrowable

        +
        @Nullable
+ @CheckReturnValue
+public @Nullable Throwable getThrowable()
        +
        Description copied from class: Subject
        +
        Returns the error that caused the Subject to terminate or null if the Subject + hasn't terminated yet. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        getThrowable in class Subject<T>
        +
        Returns:
        +
        the error that caused the Subject to terminate or null if the Subject + hasn't terminated yet
        +
        +
        • +
      + + + + + + + +
        +
      • +

        hasComplete

        +
        @CheckReturnValue
+public boolean hasComplete()
        +
        Description copied from class: Subject
        +
        Returns true if the subject has reached a terminal state through a complete event. +

        The method is thread-safe.

        +
        +
        Specified by:
        +
        hasComplete in class Subject<T>
        +
        Returns:
        +
        true if the subject has reached a terminal state through a complete event
        +
        See Also:
        +
        Subject.hasThrowable()
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
    +
  • Detail: 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/package-frame.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/package-frame.html new file mode 100644 index 0000000000..e7abe61e1d --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/package-frame.html @@ -0,0 +1,27 @@ + + + + + +io.reactivex.rxjava3.subjects (RxJava Javadoc 3.1.8) + + + + +

io.reactivex.rxjava3.subjects

+
+

Classes

+ +
+ + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/package-summary.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/package-summary.html new file mode 100644 index 0000000000..faf945b0bc --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/package-summary.html @@ -0,0 +1,247 @@ + + + + + +io.reactivex.rxjava3.subjects (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Package io.reactivex.rxjava3.subjects

+
+
Classes representing so-called hot sources, aka subjects, that implement a base reactive class and + the respective consumer type at once to allow forms of multicasting events to multiple + consumers as well as consuming another base reactive type of their kind.
+
+

See: Description

+
+
+ + + + +

Package io.reactivex.rxjava3.subjects Description

+
Classes representing so-called hot sources, aka subjects, that implement a base reactive class and + the respective consumer type at once to allow forms of multicasting events to multiple + consumers as well as consuming another base reactive type of their kind. +

+ Available subject classes with their respective base classes and consumer interfaces: +
+ + + + + + + + + + + + + + + + + + + + + + + +
The available subject classes with their respective base classes and consumer interfaces.
Subject typeBase classConsumer interface
Subject +
   AsyncSubject +
   BehaviorSubject +
   PublishSubject +
   ReplaySubject +
   UnicastSubject + 		ObservableObserver
SingleSubjectSingleSingleObserver
MaybeSubjectMaybeMaybeObserver
CompletableSubjectCompletableCompletableObserver
+

+ The backpressure-aware variants of the Subject class are called + Processors and reside in the io.reactivex.processors package.

+
+
See Also:
+
io.reactivex.rxjava3.processors
+
+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/package-tree.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/package-tree.html new file mode 100644 index 0000000000..1f92951eae --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subjects/package-tree.html @@ -0,0 +1,161 @@ + + + + + +io.reactivex.rxjava3.subjects Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For Package io.reactivex.rxjava3.subjects

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/DefaultSubscriber.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/DefaultSubscriber.html new file mode 100644 index 0000000000..56de1b3a97 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/DefaultSubscriber.html @@ -0,0 +1,408 @@ + + + + + +DefaultSubscriber (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.subscribers
+

Class DefaultSubscriber<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type + +

    Example

    
+ Flowable.range(1, 5)
+     .subscribe(new DefaultSubscriber<Integer>() {
+         @Override public void onStart() {
+             System.out.println("Start!");
+             request(1);
+         }
+         @Override public void onNext(Integer t) {
+             if (t == 3) {
+                 cancel();
+             }
+             System.out.println(t);
+             request(1);
+         }
+         @Override public void onError(Throwable t) {
+             t.printStackTrace();
+         }
+         @Override public void onComplete() {
+             System.out.println("Done!");
+         }
+     });
+
    +
    +
    +
    All Implemented Interfaces:
    +
    FlowableSubscriber<T>, Subscriber<T>
    +
    +
    +
    +
    public abstract class DefaultSubscriber<T>
+extends Object
+implements FlowableSubscriber<T>
    +
    Abstract base implementation of a Subscriber with + support for requesting via request(long), cancelling via + via cancel() (both synchronously) and calls onStart() + when the subscription happens. + +

    All pre-implemented final methods are thread-safe. + +

    The default onStart() requests Long.MAX_VALUE by default. Override + the method to request a custom positive amount. + +

    Note that calling request(long) from onStart() may trigger + an immediate, asynchronous emission of data to Subscriber.onNext(Object). Make sure + all initialization happens before the call to request() in onStart(). + Calling request(long) inside Subscriber.onNext(Object) can happen at any time + because by design, onNext calls from upstream are non-reentrant and non-overlapping. + +

    Use the protected cancel() to cancel the sequence from within an + onNext implementation. + +

    Like all other consumers, DefaultSubscriber can be subscribed only once. + Any subsequent attempt to subscribe it to a new source will yield an + IllegalStateException with message "It is not allowed to subscribe with a(n) <class name> multiple times.". + +

    Implementation of onStart(), Subscriber.onNext(Object), Subscriber.onError(Throwable) + and Subscriber.onComplete() are not allowed to throw any unchecked exceptions. + If for some reason this can't be avoided, use Flowable.safeSubscribe(org.reactivestreams.Subscriber) + instead of the standard subscribe() method.

    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        DefaultSubscriber

        +
        public DefaultSubscriber()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + + + + + +
        +
      • +

        request

        +
        protected final void request(long n)
        +
        Requests from the upstream Subscription.
        +
        +
        Parameters:
        +
        n - the request amount, positive
        +
        +
        • +
      + + + +
        +
      • +

        cancel

        +
        protected final void cancel()
        +
        Cancels the upstream's Subscription.
        +
        • +
      + + + +
        +
      • +

        onStart

        +
        protected void onStart()
        +
        Called once the subscription has been set on this observer; override this + to perform initialization or issue an initial request. +

        + The default implementation requests Long.MAX_VALUE.

        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/DisposableSubscriber.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/DisposableSubscriber.html new file mode 100644 index 0000000000..ad45cd2611 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/DisposableSubscriber.html @@ -0,0 +1,461 @@ + + + + + +DisposableSubscriber (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.subscribers
+

Class DisposableSubscriber<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the received value type.
    +
    +
    +
    All Implemented Interfaces:
    +
    FlowableSubscriber<T>, Disposable, Subscriber<T>
    +
    +
    +
    +
    public abstract class DisposableSubscriber<T>
+extends Object
+implements FlowableSubscriber<T>, Disposable
    +
    An abstract Subscriber that allows asynchronous, external cancellation by implementing Disposable. + +

    All pre-implemented final methods are thread-safe. + +

    The default onStart() requests Long.MAX_VALUE by default. Override + the method to request a custom positive amount. Use the protected request(long) + to request more items and cancel() to cancel the sequence from within an + onNext implementation. + +

    Note that calling request(long) from onStart() may trigger + an immediate, asynchronous emission of data to Subscriber.onNext(Object). Make sure + all initialization happens before the call to request() in onStart(). + Calling request(long) inside Subscriber.onNext(Object) can happen at any time + because by design, onNext calls from upstream are non-reentrant and non-overlapping. + +

    Like all other consumers, DisposableSubscriber can be subscribed only once. + Any subsequent attempt to subscribe it to a new source will yield an + IllegalStateException with message "It is not allowed to subscribe with a(n) <class name> multiple times.". + +

    Implementation of onStart(), Subscriber.onNext(Object), Subscriber.onError(Throwable) + and Subscriber.onComplete() are not allowed to throw any unchecked exceptions. + If for some reason this can't be avoided, use Flowable.safeSubscribe(org.reactivestreams.Subscriber) + instead of the standard subscribe() method. + +

    Example

    
+ Disposable d =
+     Flowable.range(1, 5)
+     .subscribeWith(new DisposableSubscriber<Integer>() {
+         @Override public void onStart() {
+             request(1);
+         }
+         @Override public void onNext(Integer t) {
+             if (t == 3) {
+                 cancel();
+             }
+             System.out.println(t);
+             request(1);
+         }
+         @Override public void onError(Throwable t) {
+             t.printStackTrace();
+         }
+         @Override public void onComplete() {
+             System.out.println("Done!");
+         }
+     });
+ // ...
+ d.dispose();
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        DisposableSubscriber

        +
        public DisposableSubscriber()
        +
        • +
      +
      • +
    + + +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/ResourceSubscriber.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/ResourceSubscriber.html new file mode 100644 index 0000000000..cd3ea1d5a6 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/ResourceSubscriber.html @@ -0,0 +1,484 @@ + + + + + +ResourceSubscriber (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.subscribers
+

Class ResourceSubscriber<T>

+
+
+ +
+
    +
  • +
    +
    Type Parameters:
    +
    T - the value type
    +
    +
    +
    All Implemented Interfaces:
    +
    FlowableSubscriber<T>, Disposable, Subscriber<T>
    +
    +
    +
    +
    public abstract class ResourceSubscriber<T>
+extends Object
+implements FlowableSubscriber<T>, Disposable
    +
    An abstract Subscriber that allows asynchronous cancellation of its + subscription and associated resources. + +

    All pre-implemented final methods are thread-safe. + +

    To release the associated resources, one has to call dispose() + in onError() and onComplete() explicitly. + +

    Use add(Disposable) to associate resources (as Disposables) + with this ResourceSubscriber that will be cleaned up when dispose() is called. + Removing previously associated resources is not possible but one can create a + CompositeDisposable, associate it with this + ResourceSubscriber and then add/remove resources to/from the CompositeDisposable + freely. + +

    The default onStart() requests Long.MAX_VALUE by default. Override + the method to request a custom positive amount. Use the protected request(long) + to request more items and dispose() to cancel the sequence from within an + onNext implementation. + +

    Note that calling request(long) from onStart() may trigger + an immediate, asynchronous emission of data to Subscriber.onNext(Object). Make sure + all initialization happens before the call to request() in onStart(). + Calling request(long) inside Subscriber.onNext(Object) can happen at any time + because by design, onNext calls from upstream are non-reentrant and non-overlapping. + +

    Like all other consumers, ResourceSubscriber can be subscribed only once. + Any subsequent attempt to subscribe it to a new source will yield an + IllegalStateException with message "It is not allowed to subscribe with a(n) <class name> multiple times.". + +

    Implementation of onStart(), Subscriber.onNext(Object), Subscriber.onError(Throwable) + and Subscriber.onComplete() are not allowed to throw any unchecked exceptions. + If for some reason this can't be avoided, use Flowable.safeSubscribe(org.reactivestreams.Subscriber) + instead of the standard subscribe() method. + +

    Example

    
+ Disposable d =
+     Flowable.range(1, 5)
+     .subscribeWith(new ResourceSubscriber<Integer>() {
+         @Override public void onStart() {
+             add(Schedulers.single()
+                 .scheduleDirect(() -> System.out.println("Time!"),
+                     2, TimeUnit.SECONDS));
+             request(1);
+         }
+         @Override public void onNext(Integer t) {
+             if (t == 3) {
+                 dispose();
+             }
+             System.out.println(t);
+             request(1);
+         }
+         @Override public void onError(Throwable t) {
+             t.printStackTrace();
+             dispose();
+         }
+         @Override public void onComplete() {
+             System.out.println("Done!");
+             dispose();
+         }
+     });
+ // ...
+ d.dispose();
+
    +
    • +
+
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        ResourceSubscriber

        +
        public ResourceSubscriber()
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        add

        +
        public final void add(Disposable resource)
        +
        Adds a resource to this ResourceSubscriber.
        +
        +
        Parameters:
        +
        resource - the resource to add
        +
        Throws:
        +
        NullPointerException - if resource is null
        +
        +
        • +
      + + + + + + + +
        +
      • +

        onStart

        +
        protected void onStart()
        +
        Called once the upstream sets a Subscription on this ResourceSubscriber. + +

        You can perform initialization at this moment. The default + implementation requests Long.MAX_VALUE from upstream.

        +
        • +
      + + + +
        +
      • +

        request

        +
        protected final void request(long n)
        +
        Request the specified amount of elements from upstream. + +

        This method can be called before the upstream calls onSubscribe(Subscription). + When the subscription happens, all missed requests are requested.

        +
        +
        Parameters:
        +
        n - the request amount, must be positive
        +
        +
        • +
      + + + +
        +
      • +

        dispose

        +
        public final void dispose()
        +
        Cancels the subscription (if any) and disposes the resources associated with + this ResourceSubscriber (if any). + +

        This method can be called before the upstream calls onSubscribe(Subscription) at which + case the Subscription will be immediately cancelled.

        +
        +
        Specified by:
        +
        dispose in interface Disposable
        +
        +
        • +
      + + + +
        +
      • +

        isDisposed

        +
        public final boolean isDisposed()
        +
        Returns true if this ResourceSubscriber has been disposed/cancelled.
        +
        +
        Specified by:
        +
        isDisposed in interface Disposable
        +
        Returns:
        +
        true if this ResourceSubscriber has been disposed/cancelled
        +
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/SafeSubscriber.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/SafeSubscriber.html new file mode 100644 index 0000000000..62620bf281 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/SafeSubscriber.html @@ -0,0 +1,395 @@ + + + + + +SafeSubscriber (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.subscribers
+

Class SafeSubscriber<T>

+
+
+ +
+ +
+
+ +
+
+ +
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/SerializedSubscriber.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/SerializedSubscriber.html new file mode 100644 index 0000000000..60d7662621 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/SerializedSubscriber.html @@ -0,0 +1,426 @@ + + + + + +SerializedSubscriber (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + +
+
io.reactivex.rxjava3.subscribers
+

Class SerializedSubscriber<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SerializedSubscriber

        +
        public SerializedSubscriber(Subscriber<? super T> downstream)
        +
        Construct a SerializedSubscriber by wrapping the given actual Subscriber.
        +
        +
        Parameters:
        +
        downstream - the actual Subscriber, not null (not verified)
        +
        +
        • +
      + + + +
        +
      • +

        SerializedSubscriber

        +
        public SerializedSubscriber(@NonNull
+                            @NonNull Subscriber<? super T> actual,
+                            boolean delayError)
        +
        Construct a SerializedSubscriber by wrapping the given actual Subscriber and + optionally delaying the errors till all regular values have been emitted + from the internal buffer.
        +
        +
        Parameters:
        +
        actual - the actual Subscriber, not null (not verified)
        +
        delayError - if true, errors are emitted after regular values have been emitted
        +
        +
        • +
      +
      • +
    + + +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+
    +
  • Summary: 
    • +
  • Nested | 
    • +
  • Field | 
    • +
  • Constr | 
    • +
  • Method
    • +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/TestSubscriber.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/TestSubscriber.html new file mode 100644 index 0000000000..e1d63562e0 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/TestSubscriber.html @@ -0,0 +1,706 @@ + + + + + +TestSubscriber (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + +
+
io.reactivex.rxjava3.subscribers
+

Class TestSubscriber<T>

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        TestSubscriber

        +
        public TestSubscriber()
        +
        Constructs a non-forwarding TestSubscriber with an initial request value of Long.MAX_VALUE.
        +
        • +
      + + + +
        +
      • +

        TestSubscriber

        +
        public TestSubscriber(long initialRequest)
        +
        Constructs a non-forwarding TestSubscriber with the specified initial request value. +

        The TestSubscriber doesn't validate the initialRequest amount so one can + test sources with invalid values as well.

        +
        +
        Parameters:
        +
        initialRequest - the initial request amount
        +
        +
        • +
      + + + +
        +
      • +

        TestSubscriber

        +
        public TestSubscriber(@NonNull Subscriber<? super T> downstream)
        +
        Constructs a forwarding TestSubscriber but leaves the requesting to the wrapped Subscriber.
        +
        +
        Parameters:
        +
        downstream - the actual Subscriber to forward events to
        +
        +
        • +
      + + + +
        +
      • +

        TestSubscriber

        +
        public TestSubscriber(@NonNull Subscriber<? super T> actual,
+        long initialRequest)
        +
        Constructs a forwarding TestSubscriber with the specified initial request amount + and an actual Subscriber to forward events to. +

        The TestSubscriber doesn't validate the initialRequest value so one can + test sources with invalid values as well.

        +
        +
        Parameters:
        +
        actual - the actual Subscriber to forward events to
        +
        initialRequest - the initial request amount
        +
        +
        • +
      +
      • +
    + + +
    • +
+
+
+ + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/package-frame.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/package-frame.html new file mode 100644 index 0000000000..f1b21611d3 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/package-frame.html @@ -0,0 +1,24 @@ + + + + + +io.reactivex.rxjava3.subscribers (RxJava Javadoc 3.1.8) + + + + +

io.reactivex.rxjava3.subscribers

+
+

Classes

+ +
+ + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/package-summary.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/package-summary.html new file mode 100644 index 0000000000..267e654fe8 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/package-summary.html @@ -0,0 +1,194 @@ + + + + + +io.reactivex.rxjava3.subscribers (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Package io.reactivex.rxjava3.subscribers

+
+
Default wrappers and implementations for Subscriber-based consumer classes and interfaces, + including disposable (DisposableSubscriber) and resource-tracking + (ResourceSubscriber) + variants and the TestSubscriber that allows unit testing + Flowable-based flows.
+
+

See: Description

+
+
+ + + + +

Package io.reactivex.rxjava3.subscribers Description

+
Default wrappers and implementations for Subscriber-based consumer classes and interfaces, + including disposable (DisposableSubscriber) and resource-tracking + (ResourceSubscriber) + variants and the TestSubscriber that allows unit testing + Flowable-based flows.
+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/package-tree.html b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/package-tree.html new file mode 100644 index 0000000000..4aa812da71 --- /dev/null +++ b/3.x/javadoc/3.1.8/io/reactivex/rxjava3/subscribers/package-tree.html @@ -0,0 +1,143 @@ + + + + + +io.reactivex.rxjava3.subscribers Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For Package io.reactivex.rxjava3.subscribers

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/overview-frame.html b/3.x/javadoc/3.1.8/overview-frame.html new file mode 100644 index 0000000000..c425dde5a7 --- /dev/null +++ b/3.x/javadoc/3.1.8/overview-frame.html @@ -0,0 +1,34 @@ + + + + + +Overview List (RxJava Javadoc 3.1.8) + + + + +
All Classes
+
+

Packages

+ +
+

 

+ + diff --git a/3.x/javadoc/3.1.8/overview-summary.html b/3.x/javadoc/3.1.8/overview-summary.html new file mode 100644 index 0000000000..eb3569b7b0 --- /dev/null +++ b/3.x/javadoc/3.1.8/overview-summary.html @@ -0,0 +1,256 @@ + + + + + +Overview (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

rxjava 3.1.8 API

+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Packages 
PackageDescription
io.reactivex.rxjava3.annotations +
Annotations for indicating operator behavior, API stability + (@Experimental and @Beta) and + nullability indicators (Nullable and NonNull).
+
io.reactivex.rxjava3.core +
Base reactive classes: Flowable, Observable, + Single, Maybe and + Completable; base reactive consumers; + other common base interfaces.
+
io.reactivex.rxjava3.disposables +
Default implementations for Disposable-based resource management + (Disposable container types) and utility classes to construct + Disposables from callbacks and other types.
+
io.reactivex.rxjava3.exceptions +
Exception handling utilities (Exceptions), + composite exception container (CompositeException) and + various lifecycle-related (UndeliverableException) + and behavior-violation exception types (OnErrorNotImplementedException, + MissingBackpressureException).
+
io.reactivex.rxjava3.flowables +
Classes supporting the Flowable base reactive class: + ConnectableFlowable and + GroupedFlowable.
+
io.reactivex.rxjava3.functions +
Functional interfaces of functions and actions of arity 0 to 9 and related + utility classes.
+
io.reactivex.rxjava3.observables +
Classes supporting the Observable base reactive class: + ConnectableObservable and + GroupedObservable.
+
io.reactivex.rxjava3.observers +
Default wrappers and implementations for observer-based consumer classes and interfaces, + including disposable and resource-tracking variants and + the TestObserver that allows unit testing + Observable-, Single-, + Maybe- and Completable-based flows.
+
io.reactivex.rxjava3.operators +
Classes and interfaces for writing advanced operators within and outside RxJava.
+
io.reactivex.rxjava3.parallel +
Contains the base type ParallelFlowable, + a sub-DSL for working with Flowable sequences in parallel.
+
io.reactivex.rxjava3.plugins +
Contains the central plugin handler RxJavaPlugins + class to hook into the lifecycle of the base reactive types and schedulers.
+
io.reactivex.rxjava3.processors +
Classes representing so-called hot backpressure-aware sources, aka processors, + that implement the FlowableProcessor class, + the Reactive Streams Processor interface + to allow forms of multicasting events to one or more subscribers as well as consuming another + Reactive Streams Publisher.
+
io.reactivex.rxjava3.schedulers +
Contains notably the factory class of Schedulers providing methods for + retrieving the standard scheduler instances, the TestScheduler for testing flows + with scheduling in a controlled manner and the class Timed that can hold + a value and a timestamp associated with it.
+
io.reactivex.rxjava3.subjects +
Classes representing so-called hot sources, aka subjects, that implement a base reactive class and + the respective consumer type at once to allow forms of multicasting events to multiple + consumers as well as consuming another base reactive type of their kind.
+
io.reactivex.rxjava3.subscribers +
Default wrappers and implementations for Subscriber-based consumer classes and interfaces, + including disposable (DisposableSubscriber) and resource-tracking + (ResourceSubscriber) + variants and the TestSubscriber that allows unit testing + Flowable-based flows.
+
+
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/overview-tree.html b/3.x/javadoc/3.1.8/overview-tree.html new file mode 100644 index 0000000000..e4fb412cbe --- /dev/null +++ b/3.x/javadoc/3.1.8/overview-tree.html @@ -0,0 +1,382 @@ + + + + + +Class Hierarchy (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Hierarchy For All Packages

+Package Hierarchies: + +
+
+

Class Hierarchy

+ +

Interface Hierarchy

+ +

Annotation Type Hierarchy

+ +

Enum Hierarchy

+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/package-list b/3.x/javadoc/3.1.8/package-list new file mode 100644 index 0000000000..4d5ce83530 --- /dev/null +++ b/3.x/javadoc/3.1.8/package-list @@ -0,0 +1,15 @@ +io.reactivex.rxjava3.annotations +io.reactivex.rxjava3.core +io.reactivex.rxjava3.disposables +io.reactivex.rxjava3.exceptions +io.reactivex.rxjava3.flowables +io.reactivex.rxjava3.functions +io.reactivex.rxjava3.observables +io.reactivex.rxjava3.observers +io.reactivex.rxjava3.operators +io.reactivex.rxjava3.parallel +io.reactivex.rxjava3.plugins +io.reactivex.rxjava3.processors +io.reactivex.rxjava3.schedulers +io.reactivex.rxjava3.subjects +io.reactivex.rxjava3.subscribers diff --git a/3.x/javadoc/3.1.8/script.js b/3.x/javadoc/3.1.8/script.js new file mode 100644 index 0000000000..b346356931 --- /dev/null +++ b/3.x/javadoc/3.1.8/script.js @@ -0,0 +1,30 @@ +function show(type) +{ + count = 0; + for (var key in methods) { + var row = document.getElementById(key); + if ((methods[key] & type) != 0) { + row.style.display = ''; + row.className = (count++ % 2) ? rowColor : altColor; + } + else + row.style.display = 'none'; + } + updateTabs(type); +} + +function updateTabs(type) +{ + for (var value in tabs) { + var sNode = document.getElementById(tabs[value][0]); + var spanNode = sNode.firstChild; + if (value == type) { + sNode.className = activeTableTab; + spanNode.innerHTML = tabs[value][1]; + } + else { + sNode.className = tableTab; + spanNode.innerHTML = "" + tabs[value][1] + ""; + } + } +} diff --git a/3.x/javadoc/3.1.8/serialized-form.html b/3.x/javadoc/3.1.8/serialized-form.html new file mode 100644 index 0000000000..75d395a7ab --- /dev/null +++ b/3.x/javadoc/3.1.8/serialized-form.html @@ -0,0 +1,243 @@ + + + + + +Serialized Form (RxJava Javadoc 3.1.8) + + + + + + + +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ +
+

Serialized Form

+
+
+ +
+ +
+ + +
Skip navigation links
+ + + + +
+
+ + + +
+ +
+ + +
+ + + diff --git a/3.x/javadoc/3.1.8/stylesheet.css b/3.x/javadoc/3.1.8/stylesheet.css new file mode 100644 index 0000000000..60f1d665bf --- /dev/null +++ b/3.x/javadoc/3.1.8/stylesheet.css @@ -0,0 +1,573 @@ +/* Javadoc style sheet */ +/* +Overall document style +*/ + +@import url('resources/fonts/dejavu.css'); + +body { + background-color:#ffffff; + color:#353833; + font-family:'DejaVu Sans', Arial, Helvetica, sans-serif; + font-size:14px; + margin:0; +} +a:link, a:visited { + text-decoration:none; + color:#4A6782; +} +a:hover, a:focus { + text-decoration:none; + color:#bb7a2a; +} +a:active { + text-decoration:none; + color:#4A6782; +} +a[name] { + color:#353833; +} +a[name]:hover { + text-decoration:none; + color:#353833; +} +pre { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; +} +h1 { + font-size:20px; +} +h2 { + font-size:18px; +} +h3 { + font-size:16px; + font-style:italic; +} +h4 { + font-size:13px; +} +h5 { + font-size:12px; +} +h6 { + font-size:11px; +} +ul { + list-style-type:disc; +} +code, tt { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + padding-top:4px; + margin-top:8px; + line-height:1.4em; +} +dt code { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + padding-top:4px; +} +table tr td dt code { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + vertical-align:top; + padding-top:4px; +} +sup { + font-size:8px; +} +/* +Document title and Copyright styles +*/ +.clear { + clear:both; + height:0px; + overflow:hidden; +} +.aboutLanguage { + float:right; + padding:0px 21px; + font-size:11px; + z-index:200; + margin-top:-9px; +} +.legalCopy { + margin-left:.5em; +} +.bar a, .bar a:link, .bar a:visited, .bar a:active { + color:#FFFFFF; + text-decoration:none; +} +.bar a:hover, .bar a:focus { + color:#bb7a2a; +} +.tab { + background-color:#0066FF; + color:#ffffff; + padding:8px; + width:5em; + font-weight:bold; +} +/* +Navigation bar styles +*/ +.bar { + background-color:#4D7A97; + color:#FFFFFF; + padding:.8em .5em .4em .8em; + height:auto;/*height:1.8em;*/ + font-size:11px; + margin:0; +} +.topNav { + background-color:#4D7A97; + color:#FFFFFF; + float:left; + padding:0; + width:100%; + clear:right; + height:2.8em; + padding-top:10px; + overflow:hidden; + font-size:12px; +} +.bottomNav { + margin-top:10px; + background-color:#4D7A97; + color:#FFFFFF; + float:left; + padding:0; + width:100%; + clear:right; + height:2.8em; + padding-top:10px; + overflow:hidden; + font-size:12px; +} +.subNav { + background-color:#dee3e9; + float:left; + width:100%; + overflow:hidden; + font-size:12px; +} +.subNav div { + clear:left; + float:left; + padding:0 0 5px 6px; + text-transform:uppercase; +} +ul.navList, ul.subNavList { + float:left; + margin:0 25px 0 0; + padding:0; +} +ul.navList li{ + list-style:none; + float:left; + padding: 5px 6px; + text-transform:uppercase; +} +ul.subNavList li{ + list-style:none; + float:left; +} +.topNav a:link, .topNav a:active, .topNav a:visited, .bottomNav a:link, .bottomNav a:active, .bottomNav a:visited { + color:#FFFFFF; + text-decoration:none; + text-transform:uppercase; +} +.topNav a:hover, .bottomNav a:hover { + text-decoration:none; + color:#bb7a2a; + text-transform:uppercase; +} +.navBarCell1Rev { + background-color:#F8981D; + color:#253441; + margin: auto 5px; +} +.skipNav { + position:absolute; + top:auto; + left:-9999px; + overflow:hidden; +} +/* +Page header and footer styles +*/ +.header, .footer { + clear:both; + margin:0 20px; + padding:5px 0 0 0; +} +.indexHeader { + margin:10px; + position:relative; +} +.indexHeader span{ + margin-right:15px; +} +.indexHeader h1 { + font-size:13px; +} +.title { + color:#2c4557; + margin:10px 0; +} +.subTitle { + margin:5px 0 0 0; +} +.header ul { + margin:0 0 15px 0; + padding:0; +} +.footer ul { + margin:20px 0 5px 0; +} +.header ul li, .footer ul li { + list-style:none; + font-size:13px; +} +/* +Heading styles +*/ +div.details ul.blockList ul.blockList ul.blockList li.blockList h4, div.details ul.blockList ul.blockList ul.blockListLast li.blockList h4 { + background-color:#dee3e9; + border:1px solid #d0d9e0; + margin:0 0 6px -8px; + padding:7px 5px; +} +ul.blockList ul.blockList ul.blockList li.blockList h3 { + background-color:#dee3e9; + border:1px solid #d0d9e0; + margin:0 0 6px -8px; + padding:7px 5px; +} +ul.blockList ul.blockList li.blockList h3 { + padding:0; + margin:15px 0; +} +ul.blockList li.blockList h2 { + padding:0px 0 20px 0; +} +/* +Page layout container styles +*/ +.contentContainer, .sourceContainer, .classUseContainer, .serializedFormContainer, .constantValuesContainer { + clear:both; + padding:10px 20px; + position:relative; +} +.indexContainer { + margin:10px; + position:relative; + font-size:12px; +} +.indexContainer h2 { + font-size:13px; + padding:0 0 3px 0; +} +.indexContainer ul { + margin:0; + padding:0; +} +.indexContainer ul li { + list-style:none; + padding-top:2px; +} +.contentContainer .description dl dt, .contentContainer .details dl dt, .serializedFormContainer dl dt { + font-size:12px; + font-weight:bold; + margin:10px 0 0 0; + color:#4E4E4E; +} +.contentContainer .description dl dd, .contentContainer .details dl dd, .serializedFormContainer dl dd { + /* margin:5px 0 10px 0px; */ + font-size:14px; + font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif; +} +.serializedFormContainer dl.nameValue dt { + margin-left:1px; + font-size:1.1em; + display:inline; + font-weight:bold; +} +.serializedFormContainer dl.nameValue dd { + margin:0 0 0 1px; + font-size:1.1em; + display:inline; +} +/* +List styles +*/ +ul.horizontal li { + display:inline; + font-size:0.9em; +} +ul.inheritance { + margin:0; + padding:0; +} +ul.inheritance li { + display:inline; + list-style:none; +} +ul.inheritance li ul.inheritance { + margin-left:15px; + padding-left:15px; + padding-top:1px; +} +ul.blockList, ul.blockListLast { + margin:10px 0 10px 0; + padding:0; +} +ul.blockList li.blockList, ul.blockListLast li.blockList { + list-style:none; + margin-bottom:15px; + line-height:1.4; +} +ul.blockList ul.blockList li.blockList, ul.blockList ul.blockListLast li.blockList { + padding:0px 20px 5px 10px; + border:1px solid #ededed; + background-color:#f8f8f8; +} +ul.blockList ul.blockList ul.blockList li.blockList, ul.blockList ul.blockList ul.blockListLast li.blockList { + padding:0 0 5px 8px; + background-color:#ffffff; + border:none; +} +ul.blockList ul.blockList ul.blockList ul.blockList li.blockList { + margin-left:0; + padding-left:0; + padding-bottom:15px; + border:none; +} +ul.blockList ul.blockList ul.blockList ul.blockList li.blockListLast { + list-style:none; + border-bottom:none; + padding-bottom:0; +} +table tr td dl, table tr td dl dt, table tr td dl dd { + margin-top:0; + margin-bottom:1px; +} +/* +Table styles +*/ +.overviewSummary, .memberSummary, .typeSummary, .useSummary, .constantsSummary, .deprecatedSummary { + width:100%; + border-left:1px solid #EEE; + border-right:1px solid #EEE; + border-bottom:1px solid #EEE; +} +.overviewSummary, .memberSummary { + padding:0px; +} +.overviewSummary caption, .memberSummary caption, .typeSummary caption, +.useSummary caption, .constantsSummary caption, .deprecatedSummary caption { + position:relative; + text-align:left; + background-repeat:no-repeat; + color:#253441; + font-weight:bold; + clear:none; + overflow:hidden; + padding:0px; + padding-top:10px; + padding-left:1px; + margin:0px; + white-space:pre; +} +.overviewSummary caption a:link, .memberSummary caption a:link, .typeSummary caption a:link, +.useSummary caption a:link, .constantsSummary caption a:link, .deprecatedSummary caption a:link, +.overviewSummary caption a:hover, .memberSummary caption a:hover, .typeSummary caption a:hover, +.useSummary caption a:hover, .constantsSummary caption a:hover, .deprecatedSummary caption a:hover, +.overviewSummary caption a:active, .memberSummary caption a:active, .typeSummary caption a:active, +.useSummary caption a:active, .constantsSummary caption a:active, .deprecatedSummary caption a:active, +.overviewSummary caption a:visited, .memberSummary caption a:visited, .typeSummary caption a:visited, +.useSummary caption a:visited, .constantsSummary caption a:visited, .deprecatedSummary caption a:visited { + color:#FFFFFF; +} +.overviewSummary caption span, .memberSummary caption span, .typeSummary caption span, +.useSummary caption span, .constantsSummary caption span, .deprecatedSummary caption span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + padding-bottom:7px; + display:inline-block; + float:left; + background-color:#F8981D; + border: none; + height:16px; +} +.memberSummary caption span.activeTableTab span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + margin-right:3px; + display:inline-block; + float:left; + background-color:#F8981D; + height:16px; +} +.memberSummary caption span.tableTab span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + margin-right:3px; + display:inline-block; + float:left; + background-color:#4D7A97; + height:16px; +} +.memberSummary caption span.tableTab, .memberSummary caption span.activeTableTab { + padding-top:0px; + padding-left:0px; + padding-right:0px; + background-image:none; + float:none; + display:inline; +} +.overviewSummary .tabEnd, .memberSummary .tabEnd, .typeSummary .tabEnd, +.useSummary .tabEnd, .constantsSummary .tabEnd, .deprecatedSummary .tabEnd { + display:none; + width:5px; + position:relative; + float:left; + background-color:#F8981D; +} +.memberSummary .activeTableTab .tabEnd { + display:none; + width:5px; + margin-right:3px; + position:relative; + float:left; + background-color:#F8981D; +} +.memberSummary .tableTab .tabEnd { + display:none; + width:5px; + margin-right:3px; + position:relative; + background-color:#4D7A97; + float:left; + +} +.overviewSummary td, .memberSummary td, .typeSummary td, +.useSummary td, .constantsSummary td, .deprecatedSummary td { + text-align:left; + padding:0px 0px 12px 10px; +} +th.colOne, th.colFirst, th.colLast, .useSummary th, .constantsSummary th, +td.colOne, td.colFirst, td.colLast, .useSummary td, .constantsSummary td{ + vertical-align:top; + padding-right:0px; + padding-top:8px; + padding-bottom:3px; +} +th.colFirst, th.colLast, th.colOne, .constantsSummary th { + background:#dee3e9; + text-align:left; + padding:8px 3px 3px 7px; +} +td.colFirst, th.colFirst { + white-space:nowrap; + font-size:13px; +} +td.colLast, th.colLast { + font-size:13px; +} +td.colOne, th.colOne { + font-size:13px; +} +.overviewSummary td.colFirst, .overviewSummary th.colFirst, +.useSummary td.colFirst, .useSummary th.colFirst, +.overviewSummary td.colOne, .overviewSummary th.colOne, +.memberSummary td.colFirst, .memberSummary th.colFirst, +.memberSummary td.colOne, .memberSummary th.colOne, +.typeSummary td.colFirst{ + width:25%; + vertical-align:top; +} +td.colOne a:link, td.colOne a:active, td.colOne a:visited, td.colOne a:hover, td.colFirst a:link, td.colFirst a:active, td.colFirst a:visited, td.colFirst a:hover, td.colLast a:link, td.colLast a:active, td.colLast a:visited, td.colLast a:hover, .constantValuesContainer td a:link, .constantValuesContainer td a:active, .constantValuesContainer td a:visited, .constantValuesContainer td a:hover { + font-weight:bold; +} +.tableSubHeadingColor { + background-color:#EEEEFF; +} +.altColor { + background-color:#FFFFFF; +} +.rowColor { + background-color:#EEEEEF; +} +/* +Content styles +*/ +.description pre { + margin-top:0; +} +.deprecatedContent { + margin:0; + padding:10px 0; +} +.docSummary { + padding:0; +} + +ul.blockList ul.blockList ul.blockList li.blockList h3 { + font-style:normal; +} + +div.block { + font-size:14px; + font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif; +} + +td.colLast div { + padding-top:0px; +} + +td.colLast a { + padding-bottom:3px; +} +/* +Formatting effect styles +*/ +.sourceLineNo { + color:green; + padding:0 30px 0 0; +} +h1.hidden { + visibility:hidden; + overflow:hidden; + font-size:10px; +} +.block { + display:block; + margin:3px 10px 2px 0px; + color:#474747; +} +.deprecatedLabel, .descfrmTypeLabel, .memberNameLabel, .memberNameLink, +.overrideSpecifyLabel, .packageHierarchyLabel, .paramLabel, .returnLabel, +.seeLabel, .simpleTagLabel, .throwsLabel, .typeNameLabel, .typeNameLink { + font-weight:bold; +} +.deprecationComment, .emphasizedPhrase, .interfaceName { + font-style:italic; +} + +div.block div.block span.deprecationComment, div.block div.block span.emphasizedPhrase, +div.block div.block span.interfaceName { + font-style:normal; +} + +div.contentContainer ul.blockList li.blockList h2{ + padding-bottom:0px; +} diff --git a/3.x/javadoc/allclasses-frame.html b/3.x/javadoc/allclasses-frame.html index dc5c7ceeb1..3f150b1dd8 100644 --- a/3.x/javadoc/allclasses-frame.html +++ b/3.x/javadoc/allclasses-frame.html @@ -3,7 +3,7 @@ -All Classes (RxJava Javadoc 3.1.7) +All Classes (RxJava Javadoc 3.1.8) diff --git a/3.x/javadoc/allclasses-noframe.html b/3.x/javadoc/allclasses-noframe.html index 8fd74654b2..7ccacd19f7 100644 --- a/3.x/javadoc/allclasses-noframe.html +++ b/3.x/javadoc/allclasses-noframe.html @@ -3,7 +3,7 @@ -All Classes (RxJava Javadoc 3.1.7) +All Classes (RxJava Javadoc 3.1.8) diff --git a/3.x/javadoc/constant-values.html b/3.x/javadoc/constant-values.html index 26543fa341..6805e4c55b 100644 --- a/3.x/javadoc/constant-values.html +++ b/3.x/javadoc/constant-values.html @@ -3,7 +3,7 @@ -Constant Field Values (RxJava Javadoc 3.1.7) +Constant Field Values (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/io/reactivex/rxjava3/annotations/package-summary.html b/3.x/javadoc/io/reactivex/rxjava3/annotations/package-summary.html index 424b58c2c9..1bac31e38b 100644 --- a/3.x/javadoc/io/reactivex/rxjava3/annotations/package-summary.html +++ b/3.x/javadoc/io/reactivex/rxjava3/annotations/package-summary.html @@ -3,7 +3,7 @@ -io.reactivex.rxjava3.annotations (RxJava Javadoc 3.1.7) +io.reactivex.rxjava3.annotations (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/io/reactivex/rxjava3/core/package-summary.html b/3.x/javadoc/io/reactivex/rxjava3/core/package-summary.html index ff4f3379ab..ca9a7d6320 100644 --- a/3.x/javadoc/io/reactivex/rxjava3/core/package-summary.html +++ b/3.x/javadoc/io/reactivex/rxjava3/core/package-summary.html @@ -3,7 +3,7 @@ -io.reactivex.rxjava3.core (RxJava Javadoc 3.1.7) +io.reactivex.rxjava3.core (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/io/reactivex/rxjava3/disposables/package-summary.html b/3.x/javadoc/io/reactivex/rxjava3/disposables/package-summary.html index 9a03a253c9..566d184cc1 100644 --- a/3.x/javadoc/io/reactivex/rxjava3/disposables/package-summary.html +++ b/3.x/javadoc/io/reactivex/rxjava3/disposables/package-summary.html @@ -3,7 +3,7 @@ -io.reactivex.rxjava3.disposables (RxJava Javadoc 3.1.7) +io.reactivex.rxjava3.disposables (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/io/reactivex/rxjava3/exceptions/package-summary.html b/3.x/javadoc/io/reactivex/rxjava3/exceptions/package-summary.html index f802f32111..850df18b75 100644 --- a/3.x/javadoc/io/reactivex/rxjava3/exceptions/package-summary.html +++ b/3.x/javadoc/io/reactivex/rxjava3/exceptions/package-summary.html @@ -3,7 +3,7 @@ -io.reactivex.rxjava3.exceptions (RxJava Javadoc 3.1.7) +io.reactivex.rxjava3.exceptions (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/io/reactivex/rxjava3/flowables/package-summary.html b/3.x/javadoc/io/reactivex/rxjava3/flowables/package-summary.html index 4563f8318f..58c7c11890 100644 --- a/3.x/javadoc/io/reactivex/rxjava3/flowables/package-summary.html +++ b/3.x/javadoc/io/reactivex/rxjava3/flowables/package-summary.html @@ -3,7 +3,7 @@ -io.reactivex.rxjava3.flowables (RxJava Javadoc 3.1.7) +io.reactivex.rxjava3.flowables (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/io/reactivex/rxjava3/functions/package-summary.html b/3.x/javadoc/io/reactivex/rxjava3/functions/package-summary.html index cafb42c2bb..3b8b786fab 100644 --- a/3.x/javadoc/io/reactivex/rxjava3/functions/package-summary.html +++ b/3.x/javadoc/io/reactivex/rxjava3/functions/package-summary.html @@ -3,7 +3,7 @@ -io.reactivex.rxjava3.functions (RxJava Javadoc 3.1.7) +io.reactivex.rxjava3.functions (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/io/reactivex/rxjava3/observables/package-summary.html b/3.x/javadoc/io/reactivex/rxjava3/observables/package-summary.html index 3d5bb5435a..f0ca485fbb 100644 --- a/3.x/javadoc/io/reactivex/rxjava3/observables/package-summary.html +++ b/3.x/javadoc/io/reactivex/rxjava3/observables/package-summary.html @@ -3,7 +3,7 @@ -io.reactivex.rxjava3.observables (RxJava Javadoc 3.1.7) +io.reactivex.rxjava3.observables (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/io/reactivex/rxjava3/observers/package-summary.html b/3.x/javadoc/io/reactivex/rxjava3/observers/package-summary.html index 3a2ff58916..8fb48a66cf 100644 --- a/3.x/javadoc/io/reactivex/rxjava3/observers/package-summary.html +++ b/3.x/javadoc/io/reactivex/rxjava3/observers/package-summary.html @@ -3,7 +3,7 @@ -io.reactivex.rxjava3.observers (RxJava Javadoc 3.1.7) +io.reactivex.rxjava3.observers (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/io/reactivex/rxjava3/operators/package-summary.html b/3.x/javadoc/io/reactivex/rxjava3/operators/package-summary.html index 07f23d8c8f..dc442a4383 100644 --- a/3.x/javadoc/io/reactivex/rxjava3/operators/package-summary.html +++ b/3.x/javadoc/io/reactivex/rxjava3/operators/package-summary.html @@ -3,7 +3,7 @@ -io.reactivex.rxjava3.operators (RxJava Javadoc 3.1.7) +io.reactivex.rxjava3.operators (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/io/reactivex/rxjava3/parallel/package-summary.html b/3.x/javadoc/io/reactivex/rxjava3/parallel/package-summary.html index 8f87ccf952..dfd5df4a40 100644 --- a/3.x/javadoc/io/reactivex/rxjava3/parallel/package-summary.html +++ b/3.x/javadoc/io/reactivex/rxjava3/parallel/package-summary.html @@ -3,7 +3,7 @@ -io.reactivex.rxjava3.parallel (RxJava Javadoc 3.1.7) +io.reactivex.rxjava3.parallel (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/io/reactivex/rxjava3/plugins/package-summary.html b/3.x/javadoc/io/reactivex/rxjava3/plugins/package-summary.html index c127493a92..9ebb85caf7 100644 --- a/3.x/javadoc/io/reactivex/rxjava3/plugins/package-summary.html +++ b/3.x/javadoc/io/reactivex/rxjava3/plugins/package-summary.html @@ -3,7 +3,7 @@ -io.reactivex.rxjava3.plugins (RxJava Javadoc 3.1.7) +io.reactivex.rxjava3.plugins (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/io/reactivex/rxjava3/processors/package-summary.html b/3.x/javadoc/io/reactivex/rxjava3/processors/package-summary.html index 28d7ed9ff0..6aa416d10e 100644 --- a/3.x/javadoc/io/reactivex/rxjava3/processors/package-summary.html +++ b/3.x/javadoc/io/reactivex/rxjava3/processors/package-summary.html @@ -3,7 +3,7 @@ -io.reactivex.rxjava3.processors (RxJava Javadoc 3.1.7) +io.reactivex.rxjava3.processors (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/io/reactivex/rxjava3/schedulers/package-summary.html b/3.x/javadoc/io/reactivex/rxjava3/schedulers/package-summary.html index f58ce9af8f..e48d1f17d3 100644 --- a/3.x/javadoc/io/reactivex/rxjava3/schedulers/package-summary.html +++ b/3.x/javadoc/io/reactivex/rxjava3/schedulers/package-summary.html @@ -3,7 +3,7 @@ -io.reactivex.rxjava3.schedulers (RxJava Javadoc 3.1.7) +io.reactivex.rxjava3.schedulers (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/io/reactivex/rxjava3/subjects/package-summary.html b/3.x/javadoc/io/reactivex/rxjava3/subjects/package-summary.html index 4d98134cb9..faf945b0bc 100644 --- a/3.x/javadoc/io/reactivex/rxjava3/subjects/package-summary.html +++ b/3.x/javadoc/io/reactivex/rxjava3/subjects/package-summary.html @@ -3,7 +3,7 @@ -io.reactivex.rxjava3.subjects (RxJava Javadoc 3.1.7) +io.reactivex.rxjava3.subjects (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/io/reactivex/rxjava3/subscribers/package-summary.html b/3.x/javadoc/io/reactivex/rxjava3/subscribers/package-summary.html index 597364ece4..267e654fe8 100644 --- a/3.x/javadoc/io/reactivex/rxjava3/subscribers/package-summary.html +++ b/3.x/javadoc/io/reactivex/rxjava3/subscribers/package-summary.html @@ -3,7 +3,7 @@ -io.reactivex.rxjava3.subscribers (RxJava Javadoc 3.1.7) +io.reactivex.rxjava3.subscribers (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ diff --git a/3.x/javadoc/overview-summary.html b/3.x/javadoc/overview-summary.html index 28ab535097..eb3569b7b0 100644 --- a/3.x/javadoc/overview-summary.html +++ b/3.x/javadoc/overview-summary.html @@ -3,7 +3,7 @@ -Overview (RxJava Javadoc 3.1.7) +Overview (RxJava Javadoc 3.1.8) @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@