Note : named this way because of overload conflict with concat ( ObservableSource< ; ObservableSource> ; )
Eager concatenation means that once a subscriber subscribes this operator subscribes to all of the source ObservableSources . The operator buffers the values emitted by these ObservableSources and then drains them in order each one after the previous one completes .
Eager concatenation means that once a subscriber subscribes this operator subscribes to all of the source ObservableSources . The operator buffers the values emitted by these ObservableSources and then drains them in order each one after the previous one completes .
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 .
Eager concatenation means that once a subscriber subscribes this operator subscribes to all of the source ObservableSources . The operator buffers the values emitted by these ObservableSources and then drains them in order each one after the previous one completes .
The { [CODESPLIT] @ BackpressureSupport ( BackpressureKind . UNBOUNDED_IN ) @ CheckReturnValue @ NonNull @ SchedulerSupport ( SchedulerSupport . NONE ) public static < T > Observable < T > fromPublisher ( Publisher < ? extends T > publisher ) { ObjectHelper . requireNonNull ( publisher , \"publisher is null\" ) ; return RxJavaPlugins . onAssembly ( new ObservableFromPublisher < T > ( publisher ) ) ; }", "target": 1, "target_options": ["no_match", "match"]} {"input": "Returns a cold synchronous and stateless generator of values .
Note that the { @link Emitter#onNext } { @link Emitter#onError } and { @link Emitter#onComplete } methods provided to the function via the { @link 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 .
Note that the { @link Emitter#onNext } { @link Emitter#onError } and { @link Emitter#onComplete } methods provided to the function via the { @link 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 .
The sequence completes immediately after the last value ( start + count - 1 ) has been reached .
The sequence completes immediately after the last value ( start + count - 1 ) has been reached .
*
Note that the item is taken and re - emitted as is and not computed by any means by { @code just } . Use { @link #fromCallable ( Callable ) } to generate a single item on demand ( when { @code Observer } s subscribe to it ) .
See the multi - parameter overloads of { @code just } to emit more than one ( constant reference ) items one after the other . Use { @link #fromArray ( Object ... ) } to emit an arbitrary number of items that are known upfront .
To emit the items of an { @link Iterable } sequence ( such as a { @link java . util . List } ) use { @link #fromIterable ( Iterable ) } .
You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource by using the { @code merge } method .
You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource by using the { @code merge } method .
You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource by using the { @code merge } method .
You can combine items emitted by multiple ObservableSources so that they appear as a single ObservableSource by using the { @code merge } method .
This behaves like { @link #merge ( ObservableSource ObservableSource ObservableSource ) } except that if any of the merged ObservableSources notify of an error via { @link Observer#onError onError } { @code mergeDelayError } will refrain from propagating that error notification until all of the merged ObservableSources have finished emitting items .
Even if multiple merged ObservableSources send { @code onError } notifications { @code mergeDelayError } will only invoke the { @code onError } method of its Observers once .
This ObservableSource is useful primarily for testing purposes .
{ @code switchOnNext } subscribes to an ObservableSource that emits ObservableSources . Each time it observes one of these emitted ObservableSources the ObservableSource returned by { @code switchOnNext } begins emitting the items emitted by that ObservableSource . When a new ObservableSource is emitted { @code switchOnNext } stops emitting items from the earlier - emitted ObservableSource and begins emitting items from the new one .
The resulting ObservableSource 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 .
{ @code switchOnNext } subscribes to an ObservableSource that emits ObservableSources . Each time it observes one of these emitted ObservableSources the ObservableSource returned by { @code switchOnNext } begins emitting the items emitted by that ObservableSource . When a new ObservableSource is emitted { @code switchOnNext } stops emitting items from the earlier - emitted ObservableSource and begins emitting items from the new one .
The resulting ObservableSource 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 signalled .
{ @code zip } applies this function in strict sequence so the first item emitted by the new ObservableSource will be the result of the function applied to the first item emitted by each of the source ObservableSources ; the second item emitted by the new ObservableSource will be the result of the function applied to the second item emitted by each of those ObservableSources ; and so forth .
The resulting { @code 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 { @code 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 : Note on method signature : since Java doesn t allow creating a generic array with { @code new T [] } the implementation of this operator has to create an { @code Object [] } instead . Unfortunately a { @code Function { @code zip } applies this function in strict sequence so the first item emitted by the new ObservableSource will be the result of the function applied to the first item emitted by each of the ObservableSources emitted by the source ObservableSource ; the second item emitted by the new ObservableSource will be the result of the function applied to the second item emitted by each of those ObservableSources ; and so forth . The resulting { @code 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 { @code 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 : Note on method signature : since Java doesn t allow creating a generic array with { @code new T [] } the implementation of this operator has to create an { @code Object [] } instead . Unfortunately a { @code Function { @code zip } applies this function in strict sequence so the first item emitted by the new ObservableSource will be the result of the function applied to the first item emitted by each of the source ObservableSources ; the second item emitted by the new ObservableSource will be the result of the function applied to the second item emitted by each of those ObservableSources ; and so forth . The resulting { @code 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 { @code 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 : Note on method signature : since Java doesn t allow creating a generic array with { @code new T [] } the implementation of this operator has to create an { @code Object [] } instead . Unfortunately a { @code Function In Rx . Net this is the { @code any } Observer but we renamed it in RxJava to better match Java naming idioms . Note : < / em > the method will only return if the upstream terminates or the current thread is interrupted . This method executes the { @code Consumer } on the current thread while { @link #subscribe ( Consumer ) } executes the consumer on the original caller thread of the sequence . If the { @link Observable } emits more than one item { @link java . util . concurrent . Future } will receive an { @link java . lang . IndexOutOfBoundsException } . If the { @link Observable } is empty { @link java . util . concurrent . Future } will receive an { @link java . util . NoSuchElementException } . The { @code Observable } source has to terminate in order for the returned { @code Future } to terminate as well . If the { @code Observable } may emit more than one item use { @code Observable . toList () . toFuture () } . If the { [CODESPLIT] @ SchedulerSupport ( SchedulerSupport . NONE ) public final void blockingSubscribe ( Consumer < ? super T > onNext ) { ObservableBlockingSubscribe . subscribe ( this , onNext , Functions . ON_ERROR_MISSING , Functions . EMPTY_ACTION ) ; }", "target": 1, "target_options": ["no_match", "match"]}
{"input": "Subscribes to the source and calls the given callbacks on the current thread< / strong > . 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 . 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 .
zip ( Arrays . asList ( range ( 1 5 ) . doOnComplete ( action1 ) range ( 6 5 ) . doOnComplete ( action2 )) ( a ) - > ; a ) < / code > < / pre > { @code action1 } will be called but { @code action2 } won t .
To work around this termination property use { @link #doOnDispose ( Action ) } as well or use { @code using () } to do cleanup in case of completion or a dispose () call .
zip ( just ( range ( 1 5 ) . doOnComplete ( action1 ) range ( 6 5 ) . doOnComplete ( action2 )) ( a ) - > ; a ) < / code > < / pre > { @code action1 } will be called but { @code action2 } won t .
To work around this termination property use { @link #doOnDispose ( Action ) } as well or use { @code using () } to do cleanup in case of completion or a dispose () call .
zip ( new ObservableSource [] { range ( 1 5 ) . doOnComplete ( action1 ) range ( 6 5 ) . doOnComplete ( action2 ) } ( a ) - > ; a ) < / code > < / pre > { @code action1 } will be called but { @code action2 } won t .
To work around this termination property use { @link #doOnDispose ( Action ) } as well or use { @code using () } to do cleanup in case of completion or a dispose () call .