From 9ec1715a900e682a11d311787227d9afaa18267c Mon Sep 17 00:00:00 2001 From: John Marks Date: Tue, 10 Sep 2013 17:00:18 +0100 Subject: [PATCH 1/9] RefCount work in progress --- .../rxjava-core/rx/operators/README.txt | 5 ++ .../rxjava-core/rx/operators/package.html | 23 +++++ classes/test/rxjava-core/README.md | 8 ++ .../test/rxjava-core/rx/operators/README.txt | 5 ++ .../rxjava-core/rx/operators/package.html | 23 +++++ rxjava-core/src/main/java/rx/Observable.java | 2 +- .../rx/observables/ConnectableObservable.java | 20 +++++ .../java/rx/operators/OperationRefCount.java | 86 +++++++++++++++++++ 8 files changed, 171 insertions(+), 1 deletion(-) create mode 100644 classes/production/rxjava-core/rx/operators/README.txt create mode 100644 classes/production/rxjava-core/rx/operators/package.html create mode 100644 classes/test/rxjava-core/README.md create mode 100644 classes/test/rxjava-core/rx/operators/README.txt create mode 100644 classes/test/rxjava-core/rx/operators/package.html create mode 100644 rxjava-core/src/main/java/rx/operators/OperationRefCount.java diff --git a/classes/production/rxjava-core/rx/operators/README.txt b/classes/production/rxjava-core/rx/operators/README.txt new file mode 100644 index 0000000000..c2d441a10c --- /dev/null +++ b/classes/production/rxjava-core/rx/operators/README.txt @@ -0,0 +1,5 @@ +This package "rx.operators" is for internal implementation details and can change at any time. + +It is excluded from the public Javadocs (http://netflix.github.io/RxJava/javadoc/) and should not be relied upon by any code. + +In short, changes to public signatures of these classes will not be accounted for in the versioning of RxJava. \ No newline at end of file diff --git a/classes/production/rxjava-core/rx/operators/package.html b/classes/production/rxjava-core/rx/operators/package.html new file mode 100644 index 0000000000..80ba7542bf --- /dev/null +++ b/classes/production/rxjava-core/rx/operators/package.html @@ -0,0 +1,23 @@ + + +

Operators that allow composing Observables to transform and + manipulate data in an asynchronous, functional and thread-safe manner.

+

The operators are all exposed via the ObservableExtensions class

+ + \ No newline at end of file diff --git a/classes/test/rxjava-core/README.md b/classes/test/rxjava-core/README.md new file mode 100644 index 0000000000..74b6c91536 --- /dev/null +++ b/classes/test/rxjava-core/README.md @@ -0,0 +1,8 @@ +This test folder only contains performance and functional/integration style tests. + +The unit tests themselves are embedded as inner classes of the Java code (such as here: [rxjava-core/src/main/java/rx/operators](https://github.com/Netflix/RxJava/tree/master/rxjava-core/src/main/java/rx/operators)). + +* For an explanation of this design choice see +Ben J. Christensen's [JUnit Tests as Inner Classes](http://benjchristensen.com/2011/10/23/junit-tests-as-inner-classes/). + +Also, each of the language adaptors has a /src/test/ folder which further testing (see Groovy for an example: [language-adaptors/rxjava-groovy/src/test](https://github.com/Netflix/RxJava/tree/master/language-adaptors/rxjava-groovy/src/test)). diff --git a/classes/test/rxjava-core/rx/operators/README.txt b/classes/test/rxjava-core/rx/operators/README.txt new file mode 100644 index 0000000000..c2d441a10c --- /dev/null +++ b/classes/test/rxjava-core/rx/operators/README.txt @@ -0,0 +1,5 @@ +This package "rx.operators" is for internal implementation details and can change at any time. + +It is excluded from the public Javadocs (http://netflix.github.io/RxJava/javadoc/) and should not be relied upon by any code. + +In short, changes to public signatures of these classes will not be accounted for in the versioning of RxJava. \ No newline at end of file diff --git a/classes/test/rxjava-core/rx/operators/package.html b/classes/test/rxjava-core/rx/operators/package.html new file mode 100644 index 0000000000..80ba7542bf --- /dev/null +++ b/classes/test/rxjava-core/rx/operators/package.html @@ -0,0 +1,23 @@ + + +

Operators that allow composing Observables to transform and + manipulate data in an asynchronous, functional and thread-safe manner.

+

The operators are all exposed via the ObservableExtensions class

+ + \ No newline at end of file diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index f6431926e9..5b4444ceb0 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -4392,7 +4392,7 @@ public BlockingObservable toBlockingObservable() { * * NOTE: If strong reasons for not depending on package names comes up then the implementation of this method can change to looking for a marker interface. * - * @param f + * @param o * @return {@code true} if the given function is an internal implementation, and {@code false} otherwise. */ private boolean isInternalImplementation(Object o) { diff --git a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java index de0fdba643..56f904ea7e 100644 --- a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java +++ b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java @@ -18,6 +18,7 @@ import rx.Observable; import rx.Observer; import rx.Subscription; +import rx.operators.OperationRefCount; import rx.util.functions.Func1; /** @@ -47,4 +48,23 @@ protected ConnectableObservable(Func1, Subscription> onSubscribe) { */ public abstract Subscription connect(); + /** + * Returns an observable sequence that stays connected to the source as long + * as there is at least one subscription to the observable sequence. + * @return a {@link Observable} + */ + public Observable refCount() { + return refCount(this); + } + + /** + * Returns an observable sequence that stays connected to the source as long + * as there is at least one subscription to the observable sequence. + * @param that + * a {@link ConnectableObservable} + * @return a {@link Observable} + */ + public static Observable refCount(ConnectableObservable that) { + return Observable.create(OperationRefCount.refCount(that)); + } } diff --git a/rxjava-core/src/main/java/rx/operators/OperationRefCount.java b/rxjava-core/src/main/java/rx/operators/OperationRefCount.java new file mode 100644 index 0000000000..11410557ea --- /dev/null +++ b/rxjava-core/src/main/java/rx/operators/OperationRefCount.java @@ -0,0 +1,86 @@ +/** + * Copyright 2013 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package rx.operators; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.MockitoAnnotations; +import rx.Observable; +import rx.Observer; +import rx.Subscription; +import rx.observables.ConnectableObservable; +import rx.subscriptions.Subscriptions; +import rx.util.functions.Func1; + +import static org.mockito.Mockito.*; + +/** + * Returns an observable sequence that stays connected to the source as long + * as there is at least one subscription to the observable sequence. + */ +public final class OperationRefCount { + public static Func1, Subscription> refCount(ConnectableObservable connectableObservable) { + return new RefCount(connectableObservable); + } + + private static class RefCount implements Func1, Subscription> { + private final ConnectableObservable innerConnectableObservable; + + public RefCount(ConnectableObservable innerConnectableObservable) { + this.innerConnectableObservable = innerConnectableObservable; + } + + @Override + public Subscription call(Observer observer) { + throw new UnsupportedOperationException(); + } + } + + public static class UnitTest { + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + } + + @Test + public void subscriptionToUnderlyingOnFirstSubscription() { + ConnectableObservable connectable = mock(ConnectableObservable.class); + Observable refCounted = Observable.create(refCount(connectable)); + Observer observer = mock(Observer.class); + when(connectable.subscribe(observer)).thenReturn(Subscriptions.empty()); + when(connectable.connect()).thenReturn(Subscriptions.empty()); + refCounted.subscribe(observer); + verify(connectable, times(1)).subscribe(observer); + verify(connectable, times(1)).connect(); + } + + @Test + public void noSubscriptionToUnderlyingOnSecondSubscription() { + + } + + @Test + public void unsubscriptionFromUnderlyingOnLastUnsubscription() { + + } + + @Test + public void noUnsubscriptionFromUnderlyingOnFirstUnsubscription() { + + } + } +} From d3d27577c7f9b20f7b543f16f025c33eb31c2fc7 Mon Sep 17 00:00:00 2001 From: John Marks Date: Tue, 10 Sep 2013 18:04:50 +0100 Subject: [PATCH 2/9] RefCount work in progress --- .../java/rx/operators/OperationRefCount.java | 70 +++++++++++++++++-- 1 file changed, 66 insertions(+), 4 deletions(-) diff --git a/rxjava-core/src/main/java/rx/operators/OperationRefCount.java b/rxjava-core/src/main/java/rx/operators/OperationRefCount.java index 11410557ea..3c64397094 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationRefCount.java +++ b/rxjava-core/src/main/java/rx/operators/OperationRefCount.java @@ -17,12 +17,15 @@ import org.junit.Before; import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; import org.mockito.MockitoAnnotations; import rx.Observable; import rx.Observer; import rx.Subscription; import rx.observables.ConnectableObservable; import rx.subscriptions.Subscriptions; +import rx.util.functions.Action0; import rx.util.functions.Func1; import static org.mockito.Mockito.*; @@ -38,6 +41,9 @@ public static Func1, Subscription> refCount(ConnectableObservabl private static class RefCount implements Func1, Subscription> { private final ConnectableObservable innerConnectableObservable; + private final Object gate = new Object(); + private int count = 0; + private Subscription connection = null; public RefCount(ConnectableObservable innerConnectableObservable) { this.innerConnectableObservable = innerConnectableObservable; @@ -45,10 +51,28 @@ public RefCount(ConnectableObservable innerConnectableObservable) { @Override public Subscription call(Observer observer) { - throw new UnsupportedOperationException(); + final Subscription subscription = innerConnectableObservable.subscribe(observer); + synchronized (gate) { + if (count++ == 0) { + connection = innerConnectableObservable.connect(); + } + } + return Subscriptions.create(new Action0() { + @Override + public void call() { + synchronized (gate) { + if (--count == 0) { + connection.unsubscribe(); + connection = null; + } + } + subscription.unsubscribe(); + } + }); } } + @RunWith(JUnit4.class) public static class UnitTest { @Before @@ -58,8 +82,10 @@ public void setUp() { @Test public void subscriptionToUnderlyingOnFirstSubscription() { + @SuppressWarnings("unchecked") ConnectableObservable connectable = mock(ConnectableObservable.class); Observable refCounted = Observable.create(refCount(connectable)); + @SuppressWarnings("unchecked") Observer observer = mock(Observer.class); when(connectable.subscribe(observer)).thenReturn(Subscriptions.empty()); when(connectable.connect()).thenReturn(Subscriptions.empty()); @@ -70,17 +96,53 @@ public void subscriptionToUnderlyingOnFirstSubscription() { @Test public void noSubscriptionToUnderlyingOnSecondSubscription() { - + @SuppressWarnings("unchecked") + ConnectableObservable connectable = mock(ConnectableObservable.class); + Observable refCounted = Observable.create(refCount(connectable)); + @SuppressWarnings("unchecked") + Observer observer = mock(Observer.class); + when(connectable.subscribe(observer)).thenReturn(Subscriptions.empty()); + when(connectable.connect()).thenReturn(Subscriptions.empty()); + refCounted.subscribe(observer); + refCounted.subscribe(observer); + verify(connectable, times(2)).subscribe(observer); + verify(connectable, times(1)).connect(); } @Test public void unsubscriptionFromUnderlyingOnLastUnsubscription() { - + @SuppressWarnings("unchecked") + ConnectableObservable connectable = mock(ConnectableObservable.class); + Observable refCounted = Observable.create(refCount(connectable)); + @SuppressWarnings("unchecked") + Observer observer = mock(Observer.class); + Subscription underlying = mock(Subscription.class); + when(connectable.subscribe(observer)).thenReturn(underlying); + Subscription connection = mock(Subscription.class); + when(connectable.connect()).thenReturn(connection); + Subscription first = refCounted.subscribe(observer); + first.unsubscribe(); + verify(underlying, times(1)).unsubscribe(); + verify(connection, times(1)).unsubscribe(); } @Test public void noUnsubscriptionFromUnderlyingOnFirstUnsubscription() { - + @SuppressWarnings("unchecked") + ConnectableObservable connectable = mock(ConnectableObservable.class); + Observable refCounted = Observable.create(refCount(connectable)); + @SuppressWarnings("unchecked") + Observer observer = mock(Observer.class); + Subscription underlying = mock(Subscription.class); + when(connectable.subscribe(observer)).thenReturn(underlying); + Subscription connection = mock(Subscription.class); + when(connectable.connect()).thenReturn(connection); + Subscription first = refCounted.subscribe(observer); + Subscription second = refCounted.subscribe(observer); + first.unsubscribe(); + second.unsubscribe(); + verify(underlying, times(2)).unsubscribe(); + verify(connection, times(1)).unsubscribe(); } } } From 531ff06861db3d7d0bf602a0a1ea446fbbefb579 Mon Sep 17 00:00:00 2001 From: John Marks Date: Wed, 11 Sep 2013 17:46:24 +0100 Subject: [PATCH 3/9] Merge and work on RefCount --- .../java/rx/observables/ConnectableObservable.java | 13 +------------ .../main/java/rx/operators/OperationRefCount.java | 1 - 2 files changed, 1 insertion(+), 13 deletions(-) diff --git a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java index d5c503edec..1595c31195 100644 --- a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java +++ b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java @@ -54,17 +54,6 @@ protected ConnectableObservable(OnSubscribeFunc onSubscribe) { * @return a {@link Observable} */ public Observable refCount() { - return refCount(this); - } - - /** - * Returns an observable sequence that stays connected to the source as long - * as there is at least one subscription to the observable sequence. - * @param that - * a {@link ConnectableObservable} - * @return a {@link Observable} - */ - public static Observable refCount(ConnectableObservable that) { - return Observable.create(OperationRefCount.refCount(that)); + return Observable.create(OperationRefCount.refCount(this)); } } diff --git a/rxjava-core/src/main/java/rx/operators/OperationRefCount.java b/rxjava-core/src/main/java/rx/operators/OperationRefCount.java index b814512a11..97cb8f738f 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationRefCount.java +++ b/rxjava-core/src/main/java/rx/operators/OperationRefCount.java @@ -70,7 +70,6 @@ public void call() { }); } - @RunWith(JUnit4.class) public static class UnitTest { @Before From b407e6e26bd0708881e3bce14e4afc9721da0bd1 Mon Sep 17 00:00:00 2001 From: John Marks Date: Wed, 11 Sep 2013 18:22:23 +0100 Subject: [PATCH 4/9] Merge and work on RefCount --- .../src/main/java/rx/Observable.java.orig | 3914 ----------------- .../rx/observables/ConnectableObservable.java | 11 +- .../java/rx/operators/OperationRefCount.java | 80 - .../src/test/java/rx/RefCountTests.java | 82 + 4 files changed, 92 insertions(+), 3995 deletions(-) delete mode 100644 rxjava-core/src/main/java/rx/Observable.java.orig create mode 100644 rxjava-core/src/test/java/rx/RefCountTests.java diff --git a/rxjava-core/src/main/java/rx/Observable.java.orig b/rxjava-core/src/main/java/rx/Observable.java.orig deleted file mode 100644 index ff79c47636..0000000000 --- a/rxjava-core/src/main/java/rx/Observable.java.orig +++ /dev/null @@ -1,3914 +0,0 @@ -/** - * Copyright 2013 Netflix, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package rx; - -import static rx.util.functions.Functions.not; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.List; -import java.util.concurrent.Future; -import java.util.concurrent.TimeUnit; - -import rx.concurrency.Schedulers; -import rx.observables.BlockingObservable; -import rx.observables.ConnectableObservable; -import rx.observables.GroupedObservable; -import rx.operators.OperationAll; -import rx.operators.OperationAverage; -import rx.operators.OperationBuffer; -import rx.operators.OperationCache; -import rx.operators.OperationCombineLatest; -import rx.operators.OperationConcat; -import rx.operators.OperationDefer; -import rx.operators.OperationDematerialize; -import rx.operators.OperationFilter; -import rx.operators.OperationFinally; -import rx.operators.OperationFirstOrDefault; -import rx.operators.OperationGroupBy; -import rx.operators.OperationInterval; -import rx.operators.OperationMap; -import rx.operators.OperationMaterialize; -import rx.operators.OperationMerge; -import rx.operators.OperationMergeDelayError; -import rx.operators.OperationMulticast; -import rx.operators.OperationObserveOn; -import rx.operators.OperationOnErrorResumeNextViaFunction; -import rx.operators.OperationOnErrorResumeNextViaObservable; -import rx.operators.OperationOnErrorReturn; -import rx.operators.OperationOnExceptionResumeNextViaObservable; -import rx.operators.OperationRetry; -import rx.operators.OperationSample; -import rx.operators.OperationScan; -import rx.operators.OperationSkip; -import rx.operators.OperationSkipWhile; -import rx.operators.OperationSubscribeOn; -import rx.operators.OperationSum; -import rx.operators.OperationSwitch; -import rx.operators.OperationSynchronize; -import rx.operators.OperationTake; -import rx.operators.OperationTakeLast; -import rx.operators.OperationTakeUntil; -import rx.operators.OperationTakeWhile; -import rx.operators.OperationTimestamp; -import rx.operators.OperationToObservableFuture; -import rx.operators.OperationToObservableIterable; -import rx.operators.OperationToObservableList; -import rx.operators.OperationToObservableSortedList; -import rx.operators.OperationWindow; -import rx.operators.OperationZip; -import rx.operators.SafeObservableSubscription; -import rx.operators.SafeObserver; -import rx.plugins.RxJavaErrorHandler; -import rx.plugins.RxJavaObservableExecutionHook; -import rx.plugins.RxJavaPlugins; -import rx.subjects.PublishSubject; -import rx.subjects.ReplaySubject; -import rx.subjects.Subject; -import rx.subscriptions.Subscriptions; -import rx.util.Closing; -import rx.util.OnErrorNotImplementedException; -import rx.util.Opening; -import rx.util.Range; -import rx.util.Timestamped; -import rx.util.functions.Action0; -import rx.util.functions.Action1; -import rx.util.functions.Func0; -import rx.util.functions.Func1; -import rx.util.functions.Func2; -import rx.util.functions.Func3; -import rx.util.functions.Func4; -import rx.util.functions.Func5; -import rx.util.functions.Func6; -import rx.util.functions.Func7; -import rx.util.functions.Func8; -import rx.util.functions.Func9; -import rx.util.functions.FuncN; -import rx.util.functions.Function; - -/** - * The Observable interface that implements the Reactive Pattern. - *

- * This interface provides overloaded methods for subscribing as well as delegate methods to the - * various operators. - *

- * The documentation for this interface makes use of marble diagrams. The following legend explains - * these diagrams: - *

- * - *

- * For more information see the RxJava Wiki - * - * @param - */ -public class Observable { - - /** - * Executed when 'subscribe' is invoked. - */ - private final OnSubscribeFunc onSubscribe; - - /** - * Function interface for work to be performed when an {@link Observable} is subscribed to via {@link Observable#subscribe(Observer)} - * - * @param - */ - public static interface OnSubscribeFunc extends Function { - - public Subscription onSubscribe(Observer t1); - - } - - /** - * Observable with Function to execute when subscribed to. - *

- * NOTE: Use {@link #create(OnSubscribeFunc)} to create an Observable instead of this constructor unless you - * specifically have a need for inheritance. - * - * @param onSubscribe - * {@link OnSubscribeFunc} to be executed when {@link #subscribe(Observer)} is called. - */ - protected Observable(OnSubscribeFunc onSubscribe) { - this.onSubscribe = onSubscribe; - } - - private final static RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook(); - - /** - * An {@link Observer} must call an Observable's {@code subscribe} method in order to - * receive items and notifications from the Observable. - * - *

A typical implementation of {@code subscribe} does the following: - *

- * It stores a reference to the Observer in a collection object, such as a {@code List} object. - *

- * It returns a reference to the {@link Subscription} interface. This enables Observers to - * unsubscribe, that is, to stop receiving items and notifications before the Observable stops - * sending them, which also invokes the Observer's {@link Observer#onCompleted onCompleted} method. - *

- * An Observable<T> instance is responsible for accepting all subscriptions - * and notifying all Observers. Unless the documentation for a particular - * Observable<T> implementation indicates otherwise, Observers should make no - * assumptions about the order in which multiple Observers will receive their notifications. - *

- * For more information see the - * RxJava Wiki - * - * @param observer - * the observer - * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items - * before the Observable has finished sending them - * @throws IllegalArgumentException - * if the {@link Observer} provided as the argument to {@code subscribe()} is {@code null} - */ - public Subscription subscribe(Observer observer) { - // allow the hook to intercept and/or decorate - OnSubscribeFunc onSubscribeFunction = hook.onSubscribeStart(this, onSubscribe); - // validate and proceed - if (observer == null) { - throw new IllegalArgumentException("observer can not be null"); - } - if (onSubscribeFunction == null) { - throw new IllegalStateException("onSubscribe function can not be null."); - // the subscribe function can also be overridden but generally that's not the appropriate approach so I won't mention that in the exception - } - try { - /** - * See https://github.com/Netflix/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls to user code from within an operator" - */ - if (isInternalImplementation(observer)) { - Subscription s = onSubscribeFunction.onSubscribe(observer); - if (s == null) { - // this generally shouldn't be the case on a 'trusted' onSubscribe but in case it happens - // we want to gracefully handle it the same as AtomicObservableSubscription does - return hook.onSubscribeReturn(this, Subscriptions.empty()); - } else { - return hook.onSubscribeReturn(this, s); - } - } else { - SafeObservableSubscription subscription = new SafeObservableSubscription(); - subscription.wrap(onSubscribeFunction.onSubscribe(new SafeObserver(subscription, observer))); - return hook.onSubscribeReturn(this, subscription); - } - } catch (OnErrorNotImplementedException e) { - // special handling when onError is not implemented ... we just rethrow - throw e; - } catch (Throwable e) { - // if an unhandled error occurs executing the onSubscribe we will propagate it - try { - observer.onError(hook.onSubscribeError(this, e)); - } catch (OnErrorNotImplementedException e2) { - // special handling when onError is not implemented ... we just rethrow - throw e2; - } catch (Throwable e2) { - // if this happens it means the onError itself failed (perhaps an invalid function implementation) - // so we are unable to propagate the error correctly and will just throw - RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2); - hook.onSubscribeError(this, r); - throw r; - } - return Subscriptions.empty(); - } - } - - /** - * An {@link Observer} must call an Observable's {@code subscribe} method in order to - * receive items and notifications from the Observable. - * - *

A typical implementation of {@code subscribe} does the following: - *

- * It stores a reference to the Observer in a collection object, such as a {@code List} object. - *

- * It returns a reference to the {@link Subscription} interface. This enables Observers to - * unsubscribe, that is, to stop receiving items and notifications before the Observable stops - * sending them, which also invokes the Observer's {@link Observer#onCompleted onCompleted} method. - *

- * An {@code Observable} instance is responsible for accepting all subscriptions - * and notifying all Observers. Unless the documentation for a particular {@code Observable} implementation indicates otherwise, Observers should make no - * assumptions about the order in which multiple Observers will receive their notifications. - *

- * For more information see the - * RxJava Wiki - * - * @param observer - * the observer - * @param scheduler - * the {@link Scheduler} on which Observers subscribe to the Observable - * @return a {@link Subscription} reference with which Observers can stop receiving items and - * notifications before the Observable has finished sending them - * @throws IllegalArgumentException - * if an argument to {@code subscribe()} is {@code null} - */ - public Subscription subscribe(Observer observer, Scheduler scheduler) { - return subscribeOn(scheduler).subscribe(observer); - } - - /** - * Used for protecting against errors being thrown from Observer implementations and ensuring onNext/onError/onCompleted contract compliance. - *

- * See https://github.com/Netflix/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls to user code from within an operator" - */ - private Subscription protectivelyWrapAndSubscribe(Observer o) { - SafeObservableSubscription subscription = new SafeObservableSubscription(); - return subscription.wrap(subscribe(new SafeObserver(subscription, o))); - } - - public Subscription subscribe(final Action1 onNext) { - if (onNext == null) { - throw new IllegalArgumentException("onNext can not be null"); - } - - /** - * Wrapping since raw functions provided by the user are being invoked. - * - * See https://github.com/Netflix/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls to user code from within an operator" - */ - return protectivelyWrapAndSubscribe(new Observer() { - - @Override - public void onCompleted() { - // do nothing - } - - @Override - public void onError(Throwable e) { - handleError(e); - throw new OnErrorNotImplementedException(e); - } - - @Override - public void onNext(T args) { - onNext.call(args); - } - - }); - } - - public Subscription subscribe(final Action1 onNext, Scheduler scheduler) { - return subscribeOn(scheduler).subscribe(onNext); - } - - public Subscription subscribe(final Action1 onNext, final Action1 onError) { - if (onNext == null) { - throw new IllegalArgumentException("onNext can not be null"); - } - if (onError == null) { - throw new IllegalArgumentException("onError can not be null"); - } - - /** - * Wrapping since raw functions provided by the user are being invoked. - * - * See https://github.com/Netflix/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls to user code from within an operator" - */ - return protectivelyWrapAndSubscribe(new Observer() { - - @Override - public void onCompleted() { - // do nothing - } - - @Override - public void onError(Throwable e) { - handleError(e); - onError.call(e); - } - - @Override - public void onNext(T args) { - onNext.call(args); - } - - }); - } - - public Subscription subscribe(final Action1 onNext, final Action1 onError, Scheduler scheduler) { - return subscribeOn(scheduler).subscribe(onNext, onError); - } - - public Subscription subscribe(final Action1 onNext, final Action1 onError, final Action0 onComplete) { - if (onNext == null) { - throw new IllegalArgumentException("onNext can not be null"); - } - if (onError == null) { - throw new IllegalArgumentException("onError can not be null"); - } - if (onComplete == null) { - throw new IllegalArgumentException("onComplete can not be null"); - } - - /** - * Wrapping since raw functions provided by the user are being invoked. - * - * See https://github.com/Netflix/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls to user code from within an operator" - */ - return protectivelyWrapAndSubscribe(new Observer() { - - @Override - public void onCompleted() { - onComplete.call(); - } - - @Override - public void onError(Throwable e) { - handleError(e); - onError.call(e); - } - - @Override - public void onNext(T args) { - onNext.call(args); - } - - }); - } - - public Subscription subscribe(final Action1 onNext, final Action1 onError, final Action0 onComplete, Scheduler scheduler) { - return subscribeOn(scheduler).subscribe(onNext, onError, onComplete); - } - - /** - * Returns a {@link ConnectableObservable} that upon connection causes the source Observable to - * push results into the specified subject. - * - * @param subject - * the {@link Subject} for the {@link ConnectableObservable} to push source items - * into - * @param - * result type - * @return a {@link ConnectableObservable} that upon connection causes the source Observable to - * push results into the specified {@link Subject} - */ - public ConnectableObservable multicast(Subject subject) { - return OperationMulticast.multicast(this, subject); - } - - /** - * Allow the {@link RxJavaErrorHandler} to receive the exception from onError. - * - * @param e - */ - private void handleError(Throwable e) { - // onError should be rare so we'll only fetch when needed - RxJavaPlugins.getInstance().getErrorHandler().handleError(e); - } - - /** - * An Observable that never sends any information to an {@link Observer}. - * - * This Observable is useful primarily for testing purposes. - * - * @param - * the type of item emitted by the Observable - */ - private static class NeverObservable extends Observable { - public NeverObservable() { - super(new OnSubscribeFunc() { - - @Override - public Subscription onSubscribe(Observer t1) { - return Subscriptions.empty(); - } - - }); - } - } - - /** - * an Observable that invokes {@link Observer#onError onError} when the {@link Observer} subscribes to it. - * - * @param - * the type of item emitted by the Observable - */ - private static class ThrowObservable extends Observable { - - public ThrowObservable(final Throwable exception) { - super(new OnSubscribeFunc() { - - /** - * Accepts an {@link Observer} and calls its {@link Observer#onError onError} method. - * - * @param observer - * an {@link Observer} of this Observable - * @return a reference to the subscription - */ - @Override - public Subscription onSubscribe(Observer observer) { - observer.onError(exception); - return Subscriptions.empty(); - } - - }); - } - - } - - /** - * Creates an Observable that will execute the given function when an {@link Observer} subscribes to it. - *

- * - *

- * Write the function you pass to create so that it behaves as an Observable: It - * should invoke the Observer's {@link Observer#onNext onNext}, {@link Observer#onError onError}, and {@link Observer#onCompleted onCompleted} methods - * appropriately. - *

- * A well-formed Observable must invoke either the Observer's onCompleted method - * exactly once or its onError method exactly once. - *

- * See Rx Design Guidelines (PDF) - * for detailed information. - * - * @param - * the type of the items that this Observable emits - * @param func - * a function that accepts an {@code Observer}, invokes its {@code onNext}, {@code onError}, and {@code onCompleted} methods - * as appropriate, and returns a {@link Subscription} to allow the Observer to - * canceling the subscription - * @return an Observable that, when an {@link Observer} subscribes to it, will execute the given - * function - */ - public static Observable create(OnSubscribeFunc func) { - return new Observable(func); - } - - /** - * Returns an Observable that emits no data to the {@link Observer} and immediately invokes - * its {@link Observer#onCompleted onCompleted} method. - *

- * - * - * @param - * the type of the items (ostensibly) emitted by the Observable - * @return an Observable that returns no data to the {@link Observer} and immediately invokes - * the {@link Observer}'s {@link Observer#onCompleted() onCompleted} method - */ - public static Observable empty() { - return from(new ArrayList()); - } - - /** - * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method when the Observer subscribes to it - *

- * - * - * @param exception - * the particular error to report - * @param - * the type of the items (ostensibly) emitted by the Observable - * @return an Observable that invokes the {@link Observer}'s {@link Observer#onError onError} method when the Observer subscribes to it - */ - public static Observable error(Throwable exception) { - return new ThrowObservable(exception); - } - - /** - * Converts an {@link Iterable} sequence into an Observable. - *

- * - * - *

Implementation note: the entire iterable sequence will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, - * it in not possible to unsubscribe from the sequence before it completes. - * - * @param iterable - * the source {@link Iterable} sequence - * @param - * the type of items in the {@link Iterable} sequence and the type of items to be - * emitted by the resulting Observable - * @return an Observable that emits each item in the source {@link Iterable} sequence - */ - public static Observable from(Iterable iterable) { - return create(OperationToObservableIterable.toObservableIterable(iterable)); - } - - /** - * Converts an Array into an Observable. - *

- * - * - *

Implementation note: the entire iterable sequence will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, - * it in not possible to unsubscribe from the sequence before it completes. - * - * @param array - * the source sequence - * @param - * the type of items in the {@link Iterable} sequence and the type of items to be - * emitted by the resulting Observable - * @return an Observable that emits each item in the source {@link Iterable} sequence - */ - public static Observable from(T[] items) { - return create(OperationToObservableIterable.toObservableIterable(Arrays.asList(items))); - } - - /** - * Converts a series of items into an Observable. - *

- * - * - *

Implementation note: the entire array will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, - * it in not possible to unsubscribe from the sequence before it completes. - * - * @param t1 - * item - * @param - * the type of items in the Array, and the type of items to be emitted by the - * resulting Observable - * @return an Observable that emits each item in the source Array - */ - @SuppressWarnings("unchecked") - // suppress unchecked because we are using varargs inside the method - public static Observable from(T t1) { - return from(Arrays.asList(t1)); - } - - /** - * Converts a series of items into an Observable. - *

- * - * - *

Implementation note: the entire array will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, - * it in not possible to unsubscribe from the sequence before it completes. - * - * @param t1 - * item - * @param t2 - * item - * @param - * the type of items in the Array, and the type of items to be emitted by the - * resulting Observable - * @return an Observable that emits each item in the source Array - */ - @SuppressWarnings("unchecked") - // suppress unchecked because we are using varargs inside the method - public static Observable from(T t1, T t2) { - return from(Arrays.asList(t1, t2)); - } - - /** - * Converts a series of items into an Observable. - *

- * - * - *

Implementation note: the entire array will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, - * it in not possible to unsubscribe from the sequence before it completes. - * - * @param t1 - * item - * @param t2 - * item - * @param t3 - * item - * @param - * the type of items in the Array, and the type of items to be emitted by the - * resulting Observable - * @return an Observable that emits each item in the source Array - */ - @SuppressWarnings("unchecked") - // suppress unchecked because we are using varargs inside the method - public static Observable from(T t1, T t2, T t3) { - return from(Arrays.asList(t1, t2, t3)); - } - - /** - * Converts a series of items into an Observable. - *

- * - * - *

Implementation note: the entire array will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, - * it in not possible to unsubscribe from the sequence before it completes. - * - * @param t1 - * item - * @param t2 - * item - * @param t3 - * item - * @param t4 - * item - * @param - * the type of items in the Array, and the type of items to be emitted by the - * resulting Observable - * @return an Observable that emits each item in the source Array - */ - @SuppressWarnings("unchecked") - // suppress unchecked because we are using varargs inside the method - public static Observable from(T t1, T t2, T t3, T t4) { - return from(Arrays.asList(t1, t2, t3, t4)); - } - - /** - * Converts a series of items into an Observable. - *

- * - * - *

Implementation note: the entire array will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, - * it in not possible to unsubscribe from the sequence before it completes. - * - * @param t1 - * item - * @param t2 - * item - * @param t3 - * item - * @param t4 - * item - * @param t5 - * item - * @param - * the type of items in the Array, and the type of items to be emitted by the - * resulting Observable - * @return an Observable that emits each item in the source Array - */ - @SuppressWarnings("unchecked") - // suppress unchecked because we are using varargs inside the method - public static Observable from(T t1, T t2, T t3, T t4, T t5) { - return from(Arrays.asList(t1, t2, t3, t4, t5)); - } - - /** - * Converts a series of items into an Observable. - *

- * - * - *

Implementation note: the entire array will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, - * it in not possible to unsubscribe from the sequence before it completes. - * - * @param t1 - * item - * @param t2 - * item - * @param t3 - * item - * @param t4 - * item - * @param t5 - * item - * @param t6 - * item - * @param - * the type of items in the Array, and the type of items to be emitted by the - * resulting Observable - * @return an Observable that emits each item in the source Array - */ - @SuppressWarnings("unchecked") - // suppress unchecked because we are using varargs inside the method - public static Observable from(T t1, T t2, T t3, T t4, T t5, T t6) { - return from(Arrays.asList(t1, t2, t3, t4, t5, t6)); - } - - /** - * Converts a series of items into an Observable. - *

- * - * - *

Implementation note: the entire array will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, - * it in not possible to unsubscribe from the sequence before it completes. - * - * @param t1 - * item - * @param t2 - * item - * @param t3 - * item - * @param t4 - * item - * @param t5 - * item - * @param t6 - * item - * @param t7 - * item - * @param - * the type of items in the Array, and the type of items to be emitted by the - * resulting Observable - * @return an Observable that emits each item in the source Array - */ - @SuppressWarnings("unchecked") - // suppress unchecked because we are using varargs inside the method - public static Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7) { - return from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7)); - } - - /** - * Converts a series of items into an Observable. - *

- * - * - *

Implementation note: the entire array will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, - * it in not possible to unsubscribe from the sequence before it completes. - * - * @param t1 - * item - * @param t2 - * item - * @param t3 - * item - * @param t4 - * item - * @param t5 - * item - * @param t6 - * item - * @param t7 - * item - * @param t8 - * item - * @param - * the type of items in the Array, and the type of items to be emitted by the - * resulting Observable - * @return an Observable that emits each item in the source Array - */ - @SuppressWarnings("unchecked") - // suppress unchecked because we are using varargs inside the method - public static Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8) { - return from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8)); - } - - /** - * Converts a series of items into an Observable. - *

- * - * - *

Implementation note: the entire array will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, - * it in not possible to unsubscribe from the sequence before it completes. - * - * @param t1 - * item - * @param t2 - * item - * @param t3 - * item - * @param t4 - * item - * @param t5 - * item - * @param t6 - * item - * @param t7 - * item - * @param t8 - * item - * @param t9 - * item - * @param - * the type of items in the Array, and the type of items to be emitted by the - * resulting Observable - * @return an Observable that emits each item in the source Array - */ - @SuppressWarnings("unchecked") - // suppress unchecked because we are using varargs inside the method - public static Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9) { - return from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8, t9)); - } - - /** - * Converts a series of items into an Observable. - *

- * - * - *

Implementation note: the entire array will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, - * it in not possible to unsubscribe from the sequence before it completes. - * - * @param t1 - * item - * @param t2 - * item - * @param t3 - * item - * @param t4 - * item - * @param t5 - * item - * @param t6 - * item - * @param t7 - * item - * @param t8 - * item - * @param t10 - * item - * @param - * the type of items in the Array, and the type of items to be emitted by the - * resulting Observable - * @return an Observable that emits each item in the source Array - */ - @SuppressWarnings("unchecked") - // suppress unchecked because we are using varargs inside the method - public static Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9, T t10) { - return from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)); - } - - /** - * Generates an Observable that emits a sequence of integers within a specified range. - *

- * - * - *

Implementation note: the entire range will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, - * it in not possible to unsubscribe from the sequence before it completes. - * - * @param start - * the value of the first integer in the sequence - * @param count - * the number of sequential integers to generate - * - * @return an Observable that emits a range of sequential integers - * - * @see Observable.Range Method (Int32, Int32) - */ - public static Observable range(int start, int count) { - return from(Range.createWithCount(start, count)); - } - - /** - * Returns an Observable that calls an Observable factory to create its Observable for each - * new Observer that subscribes. That is, for each subscriber, the actuall Observable is determined - * by the factory function. - * - *

- * - *

- * The defer operator allows you to defer or delay emitting items from an Observable until such - * time as an Observer subscribes to the Observable. This allows an {@link Observer} to easily - * obtain updates or a refreshed version of the sequence. - * - * @param observableFactory - * the Observable factory function to invoke for each {@link Observer} that - * subscribes to the resulting Observable - * @param - * the type of the items emitted by the Observable - * @return an Observable whose {@link Observer}s trigger an invocation of the given Observable - * factory function - */ - public static Observable defer(Func0> observableFactory) { - return create(OperationDefer.defer(observableFactory)); - } - - /** - * Returns an Observable that emits a single item and then completes. - *

- * - *

- * To convert any object into an Observable that emits that object, pass that object into the - * just method. - *

- * This is similar to the {@link #from(java.lang.Object[])} method, except that - * from() will convert an {@link Iterable} object into an Observable that emits - * each of the items in the Iterable, one at a time, while the just() method - * converts an Iterable into an Observable that emits the entire Iterable as a single item. - * - * @param value - * the item to pass to the {@link Observer}'s {@link Observer#onNext onNext} method - * @param - * the type of that item - * @return an Observable that emits a single item and then completes - */ - public static Observable just(T value) { - List list = new ArrayList(); - list.add(value); - - return from(list); - } - - /** - * Flattens a sequence of Observables emitted by an Observable into one Observable, without any - * transformation. - *

- * - *

- * You can combine the items emitted by multiple Observables so that they act like a single - * Observable, by using the {@code merge} method. - * - * @param source - * an Observable that emits Observables - * @return an Observable that emits items that are the result of flattening the items emitted - * by the Observables emitted by the {@code source} Observable - * @see MSDN: Observable.Merge Method - */ - public static Observable merge(Observable> source) { - return create(OperationMerge.merge(source)); - } - - /** - * Flattens a series of Observables into one Observable, without any transformation. - *

- * - *

- * You can combine items emitted by multiple Observables so that they act like a single - * Observable, by using the {@code merge} method. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted - * by the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable merge(Observable t1, Observable t2) { - return create(OperationMerge.merge(t1, t2)); - } - - /** - * Flattens a series of Observables into one Observable, without any transformation. - *

- * - *

- * You can combine items emitted by multiple Observables so that they act like a single - * Observable, by using the {@code merge} method. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @param t3 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted - * by the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable merge(Observable t1, Observable t2, Observable t3) { - return create(OperationMerge.merge(t1, t2, t3)); - } - - /** - * Flattens a series of Observables into one Observable, without any transformation. - *

- * - *

- * You can combine items emitted by multiple Observables so that they act like a single - * Observable, by using the {@code merge} method. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @param t3 - * an Observable to be merged - * @param t4 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted - * by the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable merge(Observable t1, Observable t2, Observable t3, Observable t4) { - return create(OperationMerge.merge(t1, t2, t3, t4)); - } - - /** - * Flattens a series of Observables into one Observable, without any transformation. - *

- * - *

- * You can combine items emitted by multiple Observables so that they act like a single - * Observable, by using the {@code merge} method. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @param t3 - * an Observable to be merged - * @param t4 - * an Observable to be merged - * @param t5 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted - * by the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) { - return create(OperationMerge.merge(t1, t2, t3, t4, t5)); - } - - /** - * Flattens a series of Observables into one Observable, without any transformation. - *

- * - *

- * You can combine items emitted by multiple Observables so that they act like a single - * Observable, by using the {@code merge} method. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @param t3 - * an Observable to be merged - * @param t4 - * an Observable to be merged - * @param t5 - * an Observable to be merged - * @param t6 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted - * by the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) { - return create(OperationMerge.merge(t1, t2, t3, t4, t5, t6)); - } - - /** - * Flattens a series of Observables into one Observable, without any transformation. - *

- * - *

- * You can combine items emitted by multiple Observables so that they act like a single - * Observable, by using the {@code merge} method. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @param t3 - * an Observable to be merged - * @param t4 - * an Observable to be merged - * @param t5 - * an Observable to be merged - * @param t6 - * an Observable to be merged - * @param t7 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted - * by the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) { - return create(OperationMerge.merge(t1, t2, t3, t4, t5, t6, t7)); - } - - /** - * Flattens a series of Observables into one Observable, without any transformation. - *

- * - *

- * You can combine items emitted by multiple Observables so that they act like a single - * Observable, by using the {@code merge} method. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @param t3 - * an Observable to be merged - * @param t4 - * an Observable to be merged - * @param t5 - * an Observable to be merged - * @param t6 - * an Observable to be merged - * @param t7 - * an Observable to be merged - * @param t8 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted - * by the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) { - return create(OperationMerge.merge(t1, t2, t3, t4, t5, t6, t7, t8)); - } - - /** - * Flattens a series of Observables into one Observable, without any transformation. - *

- * - *

- * You can combine items emitted by multiple Observables so that they act like a single - * Observable, by using the {@code merge} method. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @param t3 - * an Observable to be merged - * @param t4 - * an Observable to be merged - * @param t5 - * an Observable to be merged - * @param t6 - * an Observable to be merged - * @param t7 - * an Observable to be merged - * @param t8 - * an Observable to be merged - * @param t9 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted - * by the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) { - return create(OperationMerge.merge(t1, t2, t3, t4, t5, t6, t7, t8, t9)); - } - - /** - * Returns an Observable that emits the items emitted by two or more Observables, one after the - * other. - *

- * - * - * @param observables - * an Observable of Observables - * @return an Observable that emits items that are the result of combining the items emitted by - * the {@code source} Observables, one after the other - * @see MSDN: Observable.Concat Method - */ - public static Observable concat(Observable> observables) { - return create(OperationConcat.concat(observables)); - } - - /** - * Returns an Observable that emits the items emitted by two or more Observables, one after the - * other. - *

- * - * - * @param t1 - * an Observable to be concatenated - * @param t2 - * an Observable to be concatenated - * an Observable to be concatenated - * @return an Observable that emits items that are the result of combining the items emitted by - * the {@code source} Observables, one after the other - * @see MSDN: Observable.Concat Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable concat(Observable t1, Observable t2) { - return create(OperationConcat.concat(t1, t2)); - } - - /** - * Returns an Observable that emits the items emitted by two or more Observables, one after the - * other. - *

- * - * - * @param t1 - * an Observable to be concatenated - * @param t2 - * an Observable to be concatenated - * @param t3 - * an Observable to be concatenated - * an Observable to be concatenated - * @return an Observable that emits items that are the result of combining the items emitted by - * the {@code source} Observables, one after the other - * @see MSDN: Observable.Concat Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable concat(Observable t1, Observable t2, Observable t3) { - return create(OperationConcat.concat(t1, t2, t3)); - } - - /** - * Returns an Observable that emits the items emitted by two or more Observables, one after the - * other. - *

- * - * - * @param t1 - * an Observable to be concatenated - * @param t2 - * an Observable to be concatenated - * @param t3 - * an Observable to be concatenated - * @param t4 - * an Observable to be concatenated - * @return an Observable that emits items that are the result of combining the items emitted by - * the {@code source} Observables, one after the other - * @see MSDN: Observable.Concat Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable concat(Observable t1, Observable t2, Observable t3, Observable t4) { - return create(OperationConcat.concat(t1, t2, t3, t4)); - } - - /** - * Returns an Observable that emits the items emitted by two or more Observables, one after the - * other. - *

- * - * - * @param t1 - * an Observable to be concatenated - * @param t2 - * an Observable to be concatenated - * @param t3 - * an Observable to be concatenated - * @param t4 - * an Observable to be concatenated - * @param t5 - * an Observable to be concatenated - * @return an Observable that emits items that are the result of combining the items emitted by - * the {@code source} Observables, one after the other - * @see MSDN: Observable.Concat Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) { - return create(OperationConcat.concat(t1, t2, t3, t4, t5)); - } - - /** - * Returns an Observable that emits the items emitted by two or more Observables, one after the - * other. - *

- * - * - * @param t1 - * an Observable to be concatenated - * @param t2 - * an Observable to be concatenated - * @param t3 - * an Observable to be concatenated - * @param t4 - * an Observable to be concatenated - * @param t5 - * an Observable to be concatenated - * @param t6 - * an Observable to be concatenated - * @return an Observable that emits items that are the result of combining the items emitted by - * the {@code source} Observables, one after the other - * @see MSDN: Observable.Concat Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) { - return create(OperationConcat.concat(t1, t2, t3, t4, t5, t6)); - } - - /** - * Returns an Observable that emits the items emitted by two or more Observables, one after the - * other. - *

- * - * - * @param t1 - * an Observable to be concatenated - * @param t2 - * an Observable to be concatenated - * @param t3 - * an Observable to be concatenated - * @param t4 - * an Observable to be concatenated - * @param t5 - * an Observable to be concatenated - * @param t6 - * an Observable to be concatenated - * @param t7 - * an Observable to be concatenated - * @return an Observable that emits items that are the result of combining the items emitted by - * the {@code source} Observables, one after the other - * @see MSDN: Observable.Concat Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) { - return create(OperationConcat.concat(t1, t2, t3, t4, t5, t6, t7)); - } - - /** - * Returns an Observable that emits the items emitted by two or more Observables, one after the - * other. - *

- * - * - * @param t1 - * an Observable to be concatenated - * @param t2 - * an Observable to be concatenated - * @param t3 - * an Observable to be concatenated - * @param t4 - * an Observable to be concatenated - * @param t5 - * an Observable to be concatenated - * @param t6 - * an Observable to be concatenated - * @param t7 - * an Observable to be concatenated - * @param t8 - * an Observable to be concatenated - * @return an Observable that emits items that are the result of combining the items emitted by - * the {@code source} Observables, one after the other - * @see MSDN: Observable.Concat Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) { - return create(OperationConcat.concat(t1, t2, t3, t4, t5, t6, t7, t8)); - } - - /** - * Returns an Observable that emits the items emitted by two or more Observables, one after the - * other. - *

- * - * - * @param t1 - * an Observable to be concatenated - * @param t2 - * an Observable to be concatenated - * @param t3 - * an Observable to be concatenated - * @param t4 - * an Observable to be concatenated - * @param t5 - * an Observable to be concatenated - * @param t6 - * an Observable to be concatenated - * @param t7 - * an Observable to be concatenated - * @param t8 - * an Observable to be concatenated - * @param t9 - * an Observable to be concatenated - * @return an Observable that emits items that are the result of combining the items emitted by - * the {@code source} Observables, one after the other - * @see MSDN: Observable.Concat Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) { - return create(OperationConcat.concat(t1, t2, t3, t4, t5, t6, t7, t8, t9)); - } - - /** - * This behaves like {@link #merge(Observable)} except that if any of the merged Observables - * notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} will - * refrain from propagating that error notification until all of the merged Observables have - * finished emitting items. - *

- * - *

- * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only invoke the {@code onError} method of its - * Observers once. - *

- * This method allows an Observer to receive all successfully emitted items from all of the - * source Observables without being interrupted by an error notification from one of them. - * - * @param source - * an Observable that emits Observables - * @return an Observable that emits items that are the result of flattening the items emitted by - * the Observables emitted by the {@code source} Observable - * @see MSDN: Observable.Merge Method - */ - public static Observable mergeDelayError(Observable> source) { - return create(OperationMergeDelayError.mergeDelayError(source)); - } - - /** - * This behaves like {@link #merge(Observable...)} except that if any of the merged Observables - * notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} will - * refrain from propagating that error notification until all of the merged Observables have - * finished emitting items. - *

- * - *

- * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only invoke the {@code onError} method of its - * Observers once. - *

- * This method allows an Observer to receive all successfully emitted items from all of the - * source Observables without being interrupted by an error notification from one of them. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted by - * the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable mergeDelayError(Observable t1, Observable t2) { - return create(OperationMergeDelayError.mergeDelayError(t1, t2)); - } - - /** - * This behaves like {@link #merge(Observable...)} except that if any of the merged Observables - * notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} will - * refrain from propagating that error notification until all of the merged Observables have - * finished emitting items. - *

- * - *

- * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only invoke the {@code onError} method of its - * Observers once. - *

- * This method allows an Observer to receive all successfully emitted items from all of the - * source Observables without being interrupted by an error notification from one of them. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @param t3 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted by - * the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable mergeDelayError(Observable t1, Observable t2, Observable t3) { - return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3)); - } - - /** - * This behaves like {@link #merge(Observable...)} except that if any of the merged Observables - * notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} will - * refrain from propagating that error notification until all of the merged Observables have - * finished emitting items. - *

- * - *

- * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only invoke the {@code onError} method of its - * Observers once. - *

- * This method allows an Observer to receive all successfully emitted items from all of the - * source Observables without being interrupted by an error notification from one of them. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @param t3 - * an Observable to be merged - * @param t4 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted by - * the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4) { - return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3, t4)); - } - - /** - * This behaves like {@link #merge(Observable...)} except that if any of the merged Observables - * notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} will - * refrain from propagating that error notification until all of the merged Observables have - * finished emitting items. - *

- * - *

- * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only invoke the {@code onError} method of its - * Observers once. - *

- * This method allows an Observer to receive all successfully emitted items from all of the - * source Observables without being interrupted by an error notification from one of them. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @param t3 - * an Observable to be merged - * @param t4 - * an Observable to be merged - * @param t5 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted by - * the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) { - return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3, t4, t5)); - } - - /** - * This behaves like {@link #merge(Observable...)} except that if any of the merged Observables - * notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} will - * refrain from propagating that error notification until all of the merged Observables have - * finished emitting items. - *

- * - *

- * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only invoke the {@code onError} method of its - * Observers once. - *

- * This method allows an Observer to receive all successfully emitted items from all of the - * source Observables without being interrupted by an error notification from one of them. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @param t3 - * an Observable to be merged - * @param t4 - * an Observable to be merged - * @param t5 - * an Observable to be merged - * @param t6 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted by - * the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) { - return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3, t4, t5, t6)); - } - - /** - * This behaves like {@link #merge(Observable...)} except that if any of the merged Observables - * notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} will - * refrain from propagating that error notification until all of the merged Observables have - * finished emitting items. - *

- * - *

- * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only invoke the {@code onError} method of its - * Observers once. - *

- * This method allows an Observer to receive all successfully emitted items from all of the - * source Observables without being interrupted by an error notification from one of them. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @param t3 - * an Observable to be merged - * @param t4 - * an Observable to be merged - * @param t5 - * an Observable to be merged - * @param t6 - * an Observable to be merged - * @param t7 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted by - * the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) { - return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3, t4, t5, t6, t7)); - } - - /** - * This behaves like {@link #merge(Observable...)} except that if any of the merged Observables - * notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} will - * refrain from propagating that error notification until all of the merged Observables have - * finished emitting items. - *

- * - *

- * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only invoke the {@code onError} method of its - * Observers once. - *

- * This method allows an Observer to receive all successfully emitted items from all of the - * source Observables without being interrupted by an error notification from one of them. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @param t3 - * an Observable to be merged - * @param t4 - * an Observable to be merged - * @param t5 - * an Observable to be merged - * @param t6 - * an Observable to be merged - * @param t7 - * an Observable to be merged - * @param t8 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted by - * the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) { - return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3, t4, t5, t6, t7, t8)); - } - - /** - * This behaves like {@link #merge(Observable...)} except that if any of the merged Observables - * notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} will - * refrain from propagating that error notification until all of the merged Observables have - * finished emitting items. - *

- * - *

- * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only invoke the {@code onError} method of its - * Observers once. - *

- * This method allows an Observer to receive all successfully emitted items from all of the - * source Observables without being interrupted by an error notification from one of them. - * - * @param t1 - * an Observable to be merged - * @param t2 - * an Observable to be merged - * @param t3 - * an Observable to be merged - * @param t4 - * an Observable to be merged - * @param t5 - * an Observable to be merged - * @param t6 - * an Observable to be merged - * @param t7 - * an Observable to be merged - * @param t8 - * an Observable to be merged - * @param t9 - * an Observable to be merged - * @return an Observable that emits items that are the result of flattening the items emitted by - * the {@code source} Observables - * @see MSDN: Observable.Merge Method - */ - @SuppressWarnings("unchecked") - // suppress because the types are checked by the method signature before using a vararg - public static Observable mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) { - return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3, t4, t5, t6, t7, t8, t9)); - } - - /** - * Returns an Observable that never sends any items or notifications to an {@link Observer}. - *

- * - *

- * This Observable is useful primarily for testing purposes. - * - * @param - * the type of items (not) emitted by the Observable - * @return an Observable that never sends any items or notifications to an {@link Observer} - */ - public static Observable never() { - return new NeverObservable(); - } - - /** - * Given an Observable that emits Observables, creates a single Observable that - * emits the items emitted by the most recently published of those Observables. - *

- * - * - * @param sequenceOfSequences - * the source Observable that emits Observables - * @return an Observable that emits only the items emitted by the most recently published - * Observable - * @deprecated Being renamed to {@link #switchOnNext} - */ - @Deprecated - public static Observable switchDo(Observable> sequenceOfSequences) { - return create(OperationSwitch.switchDo(sequenceOfSequences)); - } - - /** - * Given an Observable that emits Observables, creates a single Observable that - * emits the items emitted by the most recently published of those Observables. - *

- * - * - * @param sequenceOfSequences - * the source Observable that emits Observables - * @return an Observable that emits only the items emitted by the most recently published - * Observable - */ - public static Observable switchOnNext(Observable> sequenceOfSequences) { - return create(OperationSwitch.switchDo(sequenceOfSequences)); - } - - - /** - * Accepts an Observable and wraps it in another Observable that ensures that the resulting - * Observable is chronologically well-behaved. - *

- * - *

- * A well-behaved Observable does not interleave its invocations of the {@link Observer#onNext onNext}, {@link Observer#onCompleted onCompleted}, and {@link Observer#onError onError} methods of - * its {@link Observer}s; it invokes {@code onCompleted} or {@code onError} only once; and it never invokes {@code onNext} after invoking either {@code onCompleted} or {@code onError}. - * {@code synchronize} enforces this, and the Observable it returns invokes {@code onNext} and {@code onCompleted} or {@code onError} synchronously. - * - * @param observable - * the source Observable - * @param - * the type of item emitted by the source Observable - * @return an Observable that is a chronologically well-behaved version of the source - * Observable, and that synchronously notifies its {@link Observer}s - */ - public static Observable synchronize(Observable observable) { - return create(OperationSynchronize.synchronize(observable)); - } - - - /** - * Emits an item each time interval (containing a sequential number). - * @param interval - * Interval size in time units (see below). - * @param unit - * Time units to use for the interval size. - * @return An Observable that emits an item each time interval. - * @see MSDN: Observable.Interval - */ - public static Observable interval(long interval, TimeUnit unit) { - return create(OperationInterval.interval(interval, unit)); - } - - /** - * Emits an item each time interval (containing a sequential number). - * @param interval - * Interval size in time units (see below). - * @param unit - * Time units to use for the interval size. - * @param scheduler - * The scheduler to use for scheduling the items. - * @return An Observable that emits an item each time interval. - * @see MSDN: Observable.Interval - */ - public static Observable interval(long interval, TimeUnit unit, Scheduler scheduler) { - return create(OperationInterval.interval(interval, unit, scheduler)); - } - - /** - * Wraps each item emitted by a source Observable in a {@link Timestamped} object. - *

- * - * - * @return an Observable that emits timestamped items from the source Observable - */ - public Observable> timestamp() { - return create(OperationTimestamp.timestamp(this)); - } - - /** - * Converts a {@link Future} into an Observable. - *

- * - *

- * You can convert any object that supports the {@link Future} interface into an Observable that - * emits the return value of the {@link Future#get} method of that object, by passing the - * object into the {@code from} method. - *

- * Important note: This Observable is blocking; you cannot unsubscribe from it. - * - * @param future - * the source {@link Future} - * @param - * the type of object that the {@link Future} returns, and also the type of item to - * be emitted by the resulting Observable - * @return an Observable that emits the item from the source Future - */ - public static Observable from(Future future) { - return create(OperationToObservableFuture.toObservableFuture(future)); - } - - /** - * Converts a {@link Future} into an Observable. - *

- * - *

- * You can convert any object that supports the {@link Future} interface into an Observable that - * emits the return value of the {@link Future#get} method of that object, by passing the - * object into the {@code from} method. - *

- * - * @param future - * the source {@link Future} - * @param scheduler - * the {@link Scheduler} to wait for the Future on. Use a Scheduler such as {@link Schedulers#threadPoolForIO()} that can block and wait on the future. - * @param - * the type of object that the {@link Future} returns, and also the type of item to - * be emitted by the resulting Observable - * @return an Observable that emits the item from the source Future - */ - public static Observable from(Future future, Scheduler scheduler) { - return create(OperationToObservableFuture.toObservableFuture(future)).subscribeOn(scheduler); - } - - /** - * Converts a {@link Future} into an Observable with timeout. - *

- * - *

- * You can convert any object that supports the {@link Future} interface into an Observable that - * emits the return value of the {link Future#get} method of that object, by passing the - * object into the {@code from} method. - *

- * Important note: This Observable is blocking; you cannot unsubscribe from it. - * - * @param future - * the source {@link Future} - * @param timeout - * the maximum time to wait before calling get() - * @param unit - * the {@link TimeUnit} of the time argument - * @param - * the type of object that the {@link Future} returns, and also the type of item to - * be emitted by the resulting Observable - * @return an Observable that emits the item from the source {@link Future} - */ - public static Observable from(Future future, long timeout, TimeUnit unit) { - return create(OperationToObservableFuture.toObservableFuture(future, timeout, unit)); - } - - /** - * Returns an Observable that emits Boolean values that indicate whether the pairs of items - * emitted by two source Observables are equal. - *

- * - * - * @param first - * one Observable to compare - * @param second - * the second Observable to compare - * @param - * the type of items emitted by each Observable - * @return an Observable that emits Booleans that indicate whether the corresponding items - * emitted by the source Observables are equal - */ - public static Observable sequenceEqual(Observable first, Observable second) { - return sequenceEqual(first, second, new Func2() { - @Override - public Boolean call(T first, T second) { - return first.equals(second); - } - }); - } - - /** - * Returns an Observable that emits Boolean values that indicate whether the pairs of items - * emitted by two source Observables are equal based on the results of a specified equality - * function. - *

- * - * - * @param first - * one Observable to compare - * @param second - * the second Observable to compare - * @param equality - * a function used to compare items emitted by both Observables - * @param - * the type of items emitted by each Observable - * @return an Observable that emits Booleans that indicate whether the corresponding items - * emitted by the source Observables are equal - */ - public static Observable sequenceEqual(Observable first, Observable second, Func2 equality) { - return zip(first, second, equality); - } - - /** - * Returns an Observable that emits the results of a function of your choosing applied to - * combinations of two items emitted, in sequence, by two other Observables. - *

- * - *

{@code zip} applies this function in strict sequence, so the first item emitted by the - * new Observable will be the result of the function applied to the first item emitted by {@code w0} and the first item emitted by {@code w1}; the second item emitted by - * the new Observable will be the result of the function applied to the second item emitted by {@code w0} and the second item emitted by {@code w1}; and so forth. - *

- * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations - * of the source Observable that emits the fewest items. - * - * @param o1 - * one source Observable - * @param o2 - * another source Observable - * @param zipFunction - * a function that, when applied to an item emitted by each of the source - * Observables, results in an item that will be emitted by the resulting Observable - * @return an Observable that emits the zipped results - */ - public static Observable zip(Observable o1, Observable o2, Func2 zipFunction) { - return create(OperationZip.zip(o1, o2, zipFunction)); - } - - /** - * Returns an Observable that emits the results of a function of your choosing applied to - * combinations of three items emitted, in sequence, by three other Observables. - *

- * - *

{@code zip} applies this function in strict sequence, so the first item emitted by the - * new Observable will be the result of the function applied to the first item emitted by {@code w0}, the first item emitted by {@code w1}, and the first item emitted by {@code w2}; the second - * item emitted by the new Observable will be the result of the - * function applied to the second item emitted by {@code w0}, the second item emitted by {@code w1}, and the second item emitted by {@code w2}; and so forth. - *

- * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations - * of the source Observable that emits the fewest items. - * - * @param o1 - * one source Observable - * @param o2 - * a second source Observable - * @param o3 - * a third source Observable - * @param zipFunction - * a function that, when applied to an item emitted by each of the source - * Observables, results in an item that will be emitted by the resulting Observable - * @return an Observable that emits the zipped results - */ - public static Observable zip(Observable o1, Observable o2, Observable o3, Func3 zipFunction) { - return create(OperationZip.zip(o1, o2, o3, zipFunction)); - } - - /** - * Returns an Observable that emits the results of a function of your choosing applied to - * combinations of four items emitted, in sequence, by four other Observables. - *

- * - *

{@code zip} applies this function in strict sequence, so the first item emitted by the - * new Observable will be the result of the function applied to the first item emitted by {@code w0}, the first item emitted by {@code w1}, the first item emitted by {@code w2}, and the first item - * emitted by {@code w3}; the second item emitted by - * the new Observable will be the result of the function applied to the second item emitted by - * each of those Observables; and so forth. - *

- * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations - * of the source Observable that emits the fewest items. - * - * @param o1 - * one source Observable - * @param o2 - * a second source Observable - * @param o3 - * a third source Observable - * @param o4 - * a fourth source Observable - * @param zipFunction - * a function that, when applied to an item emitted by each of the source - * Observables, results in an item that will be emitted by the resulting Observable - * @return an Observable that emits the zipped results - */ - public static Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Func4 zipFunction) { - return create(OperationZip.zip(o1, o2, o3, o4, zipFunction)); - } - - /** - * Returns an Observable that emits the results of a function of your choosing applied to - * combinations of five items emitted, in sequence, by five other Observables. - *

- * - *

{@code zip} applies this function in strict sequence, so the first item emitted by the - * new Observable will be the result of the function applied to the first item emitted by {@code w0}, the first item emitted by {@code w1}, the first item emitted by {@code w2}, and the first item - * emitted by {@code w3}; the second item emitted by - * the new Observable will be the result of the function applied to the second item emitted by - * each of those Observables; and so forth. - *

- * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations - * of the source Observable that emits the fewest items. - * - * @param o1 - * one source Observable - * @param o2 - * a second source Observable - * @param o3 - * a third source Observable - * @param o4 - * a fourth source Observable - * @param o5 - * a fifth source Observable - * @param zipFunction - * a function that, when applied to an item emitted by each of the source - * Observables, results in an item that will be emitted by the resulting Observable - * @return an Observable that emits the zipped results - */ - public static Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Func5 zipFunction) { - return create(OperationZip.zip(o1, o2, o3, o4, o5, zipFunction)); - } - - /** - * Returns an Observable that emits the results of a function of your choosing applied to - * combinations of six items emitted, in sequence, by six other Observables. - *

- * - *

{@code zip} applies this function in strict sequence, so the first item emitted by the - * new Observable will be the result of the function applied to the first item emitted by {@code w0}, the first item emitted by {@code w1}, the first item emitted by {@code w2}, and the first item - * emitted by {@code w3}; the second item emitted by - * the new Observable will be the result of the function applied to the second item emitted by - * each of those Observables; and so forth. - *

- * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations - * of the source Observable that emits the fewest items. - * - * @param o1 - * one source Observable - * @param o2 - * a second source Observable - * @param o3 - * a third source Observable - * @param o4 - * a fourth source Observable - * @param o5 - * a fifth source Observable - * @param o6 - * a sixth source Observable - * @param zipFunction - * a function that, when applied to an item emitted by each of the source - * Observables, results in an item that will be emitted by the resulting Observable - * @return an Observable that emits the zipped results - */ - public static Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, - Func6 zipFunction) { - return create(OperationZip.zip(o1, o2, o3, o4, o5, o6, zipFunction)); - } - - /** - * Returns an Observable that emits the results of a function of your choosing applied to - * combinations of seven items emitted, in sequence, by seven other Observables. - *

- * - *

{@code zip} applies this function in strict sequence, so the first item emitted by the - * new Observable will be the result of the function applied to the first item emitted by {@code w0}, the first item emitted by {@code w1}, the first item emitted by {@code w2}, and the first item - * emitted by {@code w3}; the second item emitted by - * the new Observable will be the result of the function applied to the second item emitted by - * each of those Observables; and so forth. - *

- * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations - * of the source Observable that emits the fewest items. - * - * @param o1 - * one source Observable - * @param o2 - * a second source Observable - * @param o3 - * a third source Observable - * @param o4 - * a fourth source Observable - * @param o5 - * a fifth source Observable - * @param o6 - * a sixth source Observable - * @param o7 - * a seventh source Observable - * @param zipFunction - * a function that, when applied to an item emitted by each of the source - * Observables, results in an item that will be emitted by the resulting Observable - * @return an Observable that emits the zipped results - */ - public static Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, - Func7 zipFunction) { - return create(OperationZip.zip(o1, o2, o3, o4, o5, o6, o7, zipFunction)); - } - - /** - * Returns an Observable that emits the results of a function of your choosing applied to - * combinations of eight items emitted, in sequence, by eight other Observables. - *

- * - *

{@code zip} applies this function in strict sequence, so the first item emitted by the - * new Observable will be the result of the function applied to the first item emitted by {@code w0}, the first item emitted by {@code w1}, the first item emitted by {@code w2}, and the first item - * emitted by {@code w3}; the second item emitted by - * the new Observable will be the result of the function applied to the second item emitted by - * each of those Observables; and so forth. - *

- * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations - * of the source Observable that emits the fewest items. - * - * @param o1 - * one source Observable - * @param o2 - * a second source Observable - * @param o3 - * a third source Observable - * @param o4 - * a fourth source Observable - * @param o5 - * a fifth source Observable - * @param o6 - * a sixth source Observable - * @param o7 - * a seventh source Observable - * @param o8 - * an eighth source Observable - * @param zipFunction - * a function that, when applied to an item emitted by each of the source - * Observables, results in an item that will be emitted by the resulting Observable - * @return an Observable that emits the zipped results - */ - public static Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, - Func8 zipFunction) { - return create(OperationZip.zip(o1, o2, o3, o4, o5, o6, o7, o8, zipFunction)); - } - - /** - * Returns an Observable that emits the results of a function of your choosing applied to - * combinations of nine items emitted, in sequence, by nine other Observables. - *

- * - *

{@code zip} applies this function in strict sequence, so the first item emitted by the - * new Observable will be the result of the function applied to the first item emitted by {@code w0}, the first item emitted by {@code w1}, the first item emitted by {@code w2}, and the first item - * emitted by {@code w3}; the second item emitted by - * the new Observable will be the result of the function applied to the second item emitted by - * each of those Observables; and so forth. - *

- * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations - * of the source Observable that emits the fewest items. - * - * @param o1 - * one source Observable - * @param o2 - * a second source Observable - * @param o3 - * a third source Observable - * @param o4 - * a fourth source Observable - * @param o5 - * a fifth source Observable - * @param o6 - * a sixth source Observable - * @param o7 - * a seventh source Observable - * @param o8 - * an eighth source Observable - * @param o9 - * a ninth source Observable - * @param zipFunction - * a function that, when applied to an item emitted by each of the source - * Observables, results in an item that will be emitted by the resulting Observable - * @return an Observable that emits the zipped results - */ - public static Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, - Observable o9, Func9 zipFunction) { - return create(OperationZip.zip(o1, o2, o3, o4, o5, o6, o7, o8, o9, zipFunction)); - } - - /** - * Combines the given observables, emitting an event containing an aggregation of the latest values of each of the source observables - * each time an event is received from one of the source observables, where the aggregation is defined by the given function. - *

- * - * - * @param o1 - * The first source observable. - * @param o2 - * The second source observable. - * @param combineFunction - * The aggregation function used to combine the source observable values. - * @return An Observable that combines the source Observables with the given combine function - */ - public static Observable combineLatest(Observable o1, Observable o2, Func2 combineFunction) { - return create(OperationCombineLatest.combineLatest(o1, o2, combineFunction)); - } - - /** - * @see #combineLatest(Observable, Observable, Func2) - */ - public static Observable combineLatest(Observable o1, Observable o2, Observable o3, Func3 combineFunction) { - return create(OperationCombineLatest.combineLatest(o1, o2, o3, combineFunction)); - } - - /** - * @see #combineLatest(Observable, Observable, Func2) - */ - public static Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, - Func4 combineFunction) { - return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, combineFunction)); - } - - /** - * @see #combineLatest(Observable, Observable, Func2) - */ - public static Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, - Func5 combineFunction) { - return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, combineFunction)); - } - - /** - * @see #combineLatest(Observable, Observable, Func2) - */ - public static Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, - Func6 combineFunction) { - return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, o6, combineFunction)); - } - - /** - * @see #combineLatest(Observable, Observable, Func2) - */ - public static Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, - Func7 combineFunction) { - return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, o6, o7, combineFunction)); - } - - /** - * @see #combineLatest(Observable, Observable, Func2) - */ - public static Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, - Func8 combineFunction) { - return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, o6, o7, o8, combineFunction)); - } - - /** - * @see #combineLatest(Observable, Observable, Func2) - */ - public static Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Observable o9, - Func9 combineFunction) { - return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, o6, o7, o8, o9, combineFunction)); - } - - /** - * Creates an Observable which produces buffers of collected values. - * - *

This Observable produces connected non-overlapping buffers. The current buffer is - * emitted and replaced with a new buffer when the Observable produced by the specified {@link Func0} produces a {@link rx.util.Closing} object. The * {@link Func0} will then - * be used to create a new Observable to listen for the end of the next buffer. - * - * @param bufferClosingSelector - * The {@link Func0} which is used to produce an {@link Observable} for every buffer created. - * When this {@link Observable} produces a {@link rx.util.Closing} object, the associated buffer - * is emitted and replaced with a new one. - * @return - * An {@link Observable} which produces connected non-overlapping buffers, which are emitted - * when the current {@link Observable} created with the {@link Func0} argument produces a {@link rx.util.Closing} object. - */ - public Observable> buffer(Func0> bufferClosingSelector) { - return create(OperationBuffer.buffer(this, bufferClosingSelector)); - } - - /** - * Creates an Observable which produces buffers of collected values. - * - *

This Observable produces buffers. Buffers are created when the specified "bufferOpenings" - * Observable produces a {@link rx.util.Opening} object. Additionally the {@link Func0} argument - * is used to create an Observable which produces {@link rx.util.Closing} objects. When this - * Observable produces such an object, the associated buffer is emitted. - * - * @param bufferOpenings - * The {@link Observable} which, when it produces a {@link rx.util.Opening} object, will cause - * another buffer to be created. - * @param bufferClosingSelector - * The {@link Func0} which is used to produce an {@link Observable} for every buffer created. - * When this {@link Observable} produces a {@link rx.util.Closing} object, the associated buffer - * is emitted. - * @return - * An {@link Observable} which produces buffers which are created and emitted when the specified {@link Observable}s publish certain objects. - */ - public Observable> buffer(Observable bufferOpenings, Func1> bufferClosingSelector) { - return create(OperationBuffer.buffer(this, bufferOpenings, bufferClosingSelector)); - } - - /** - * Creates an Observable which produces buffers of collected values. - * - *

This Observable produces connected non-overlapping buffers, each containing "count" - * elements. When the source Observable completes or encounters an error, the current - * buffer is emitted, and the event is propagated. - * - * @param count - * The maximum size of each buffer before it should be emitted. - * @return - * An {@link Observable} which produces connected non-overlapping buffers containing at most - * "count" produced values. - */ - public Observable> buffer(int count) { - return create(OperationBuffer.buffer(this, count)); - } - - /** - * Creates an Observable which produces buffers of collected values. - * - *

This Observable produces buffers every "skip" values, each containing "count" - * elements. When the source Observable completes or encounters an error, the current - * buffer is emitted, and the event is propagated. - * - * @param count - * The maximum size of each buffer before it should be emitted. - * @param skip - * How many produced values need to be skipped before starting a new buffer. Note that when "skip" and - * "count" are equals that this is the same operation as {@link Observable#buffer(int)}. - * @return - * An {@link Observable} which produces buffers every "skipped" values containing at most - * "count" produced values. - */ - public Observable> buffer(int count, int skip) { - return create(OperationBuffer.buffer(this, count, skip)); - } - - /** - * Creates an Observable which produces buffers of collected values. - * - *

This Observable produces connected non-overlapping buffers, each of a fixed duration - * specified by the "timespan" argument. When the source Observable completes or encounters - * an error, the current buffer is emitted and the event is propagated. - * - * @param timespan - * The period of time each buffer is collecting values before it should be emitted, and - * replaced with a new buffer. - * @param unit - * The unit of time which applies to the "timespan" argument. - * @return - * An {@link Observable} which produces connected non-overlapping buffers with a fixed duration. - */ - public Observable> buffer(long timespan, TimeUnit unit) { - return create(OperationBuffer.buffer(this, timespan, unit)); - } - - /** - * Creates an Observable which produces buffers of collected values. - * - *

This Observable produces connected non-overlapping buffers, each of a fixed duration - * specified by the "timespan" argument. When the source Observable completes or encounters - * an error, the current buffer is emitted and the event is propagated. - * - * @param timespan - * The period of time each buffer is collecting values before it should be emitted, and - * replaced with a new buffer. - * @param unit - * The unit of time which applies to the "timespan" argument. - * @param scheduler - * The {@link Scheduler} to use when determining the end and start of a buffer. - * @return - * An {@link Observable} which produces connected non-overlapping buffers with a fixed duration. - */ - public Observable> buffer(long timespan, TimeUnit unit, Scheduler scheduler) { - return create(OperationBuffer.buffer(this, timespan, unit, scheduler)); - } - - /** - * Creates an Observable which produces buffers of collected values. This Observable produces connected - * non-overlapping buffers, each of a fixed duration specified by the "timespan" argument or a maximum size - * specified by the "count" argument (which ever is reached first). When the source Observable completes - * or encounters an error, the current buffer is emitted and the event is propagated. - * - * @param timespan - * The period of time each buffer is collecting values before it should be emitted, and - * replaced with a new buffer. - * @param unit - * The unit of time which applies to the "timespan" argument. - * @param count - * The maximum size of each buffer before it should be emitted. - * @return - * An {@link Observable} which produces connected non-overlapping buffers which are emitted after - * a fixed duration or when the buffer has reached maximum capacity (which ever occurs first). - */ - public Observable> buffer(long timespan, TimeUnit unit, int count) { - return create(OperationBuffer.buffer(this, timespan, unit, count)); - } - - /** - * Creates an Observable which produces buffers of collected values. This Observable produces connected - * non-overlapping buffers, each of a fixed duration specified by the "timespan" argument or a maximum size - * specified by the "count" argument (which ever is reached first). When the source Observable completes - * or encounters an error, the current buffer is emitted and the event is propagated. - * - * @param timespan - * The period of time each buffer is collecting values before it should be emitted, and - * replaced with a new buffer. - * @param unit - * The unit of time which applies to the "timespan" argument. - * @param count - * The maximum size of each buffer before it should be emitted. - * @param scheduler - * The {@link Scheduler} to use when determining the end and start of a buffer. - * @return - * An {@link Observable} which produces connected non-overlapping buffers which are emitted after - * a fixed duration or when the buffer has reached maximum capacity (which ever occurs first). - */ - public Observable> buffer(long timespan, TimeUnit unit, int count, Scheduler scheduler) { - return create(OperationBuffer.buffer(this, timespan, unit, count, scheduler)); - } - - /** - * Creates an Observable which produces buffers of collected values. This Observable starts a new buffer - * periodically, which is determined by the "timeshift" argument. Each buffer is emitted after a fixed timespan - * specified by the "timespan" argument. When the source Observable completes or encounters an error, the - * current buffer is emitted and the event is propagated. - * - * @param timespan - * The period of time each buffer is collecting values before it should be emitted. - * @param timeshift - * The period of time after which a new buffer will be created. - * @param unit - * The unit of time which applies to the "timespan" and "timeshift" argument. - * @return - * An {@link Observable} which produces new buffers periodically, and these are emitted after - * a fixed timespan has elapsed. - */ - public Observable> buffer(long timespan, long timeshift, TimeUnit unit) { - return create(OperationBuffer.buffer(this, timespan, timeshift, unit)); - } - - /** - * Creates an Observable which produces buffers of collected values. This Observable starts a new buffer - * periodically, which is determined by the "timeshift" argument. Each buffer is emitted after a fixed timespan - * specified by the "timespan" argument. When the source Observable completes or encounters an error, the - * current buffer is emitted and the event is propagated. - * - * @param timespan - * The period of time each buffer is collecting values before it should be emitted. - * @param timeshift - * The period of time after which a new buffer will be created. - * @param unit - * The unit of time which applies to the "timespan" and "timeshift" argument. - * @param scheduler - * The {@link Scheduler} to use when determining the end and start of a buffer. - * @return - * An {@link Observable} which produces new buffers periodically, and these are emitted after - * a fixed timespan has elapsed. - */ - public Observable> buffer(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) { - return create(OperationBuffer.buffer(this, timespan, timeshift, unit, scheduler)); - } - - /** - * Creates an Observable which produces windows of collected values. This Observable produces connected - * non-overlapping windows. The current window is emitted and replaced with a new window when the - * Observable produced by the specified {@link Func0} produces a {@link rx.util.Closing} object. The {@link Func0} will then be used to create a new Observable to listen for the end of the next - * window. - * - * @param closingSelector - * The {@link Func0} which is used to produce an {@link Observable} for every window created. - * When this {@link Observable} produces a {@link rx.util.Closing} object, the associated window - * is emitted and replaced with a new one. - * @return - * An {@link Observable} which produces connected non-overlapping windows, which are emitted - * when the current {@link Observable} created with the {@link Func0} argument produces a {@link rx.util.Closing} object. - */ - public Observable> window(Func0> closingSelector) { - return create(OperationWindow.window(this, closingSelector)); - } - - /** - * Creates an Observable which produces windows of collected values. This Observable produces windows. - * Chunks are created when the specified "windowOpenings" Observable produces a {@link rx.util.Opening} object. - * Additionally the {@link Func0} argument is used to create an Observable which produces {@link rx.util.Closing} objects. When this Observable produces such an object, the associated window is - * emitted. - * - * @param windowOpenings - * The {@link Observable} which when it produces a {@link rx.util.Opening} object, will cause - * another window to be created. - * @param closingSelector - * The {@link Func0} which is used to produce an {@link Observable} for every window created. - * When this {@link Observable} produces a {@link rx.util.Closing} object, the associated window - * is emitted. - * @return - * An {@link Observable} which produces windows which are created and emitted when the specified {@link Observable}s publish certain objects. - */ - public Observable> window(Observable windowOpenings, Func1> closingSelector) { - return create(OperationWindow.window(this, windowOpenings, closingSelector)); - } - - /** - * Creates an Observable which produces windows of collected values. This Observable produces connected - * non-overlapping windows, each containing "count" elements. When the source Observable completes or - * encounters an error, the current window is emitted, and the event is propagated. - * - * @param count - * The maximum size of each window before it should be emitted. - * @return - * An {@link Observable} which produces connected non-overlapping windows containing at most - * "count" produced values. - */ - public Observable> window(int count) { - return create(OperationWindow.window(this, count)); - } - - /** - * Creates an Observable which produces windows of collected values. This Observable produces windows every - * "skip" values, each containing "count" elements. When the source Observable completes or encounters an error, - * the current window is emitted and the event is propagated. - * - * @param count - * The maximum size of each window before it should be emitted. - * @param skip - * How many produced values need to be skipped before starting a new window. Note that when "skip" and - * "count" are equals that this is the same operation as {@link Observable#window(Observable, int)}. - * @return - * An {@link Observable} which produces windows every "skipped" values containing at most - * "count" produced values. - */ - public Observable> window(int count, int skip) { - return create(OperationWindow.window(this, count, skip)); - } - - /** - * Creates an Observable which produces windows of collected values. This Observable produces connected - * non-overlapping windows, each of a fixed duration specified by the "timespan" argument. When the source - * Observable completes or encounters an error, the current window is emitted and the event is propagated. - * - * @param timespan - * The period of time each window is collecting values before it should be emitted, and - * replaced with a new window. - * @param unit - * The unit of time which applies to the "timespan" argument. - * @return - * An {@link Observable} which produces connected non-overlapping windows with a fixed duration. - */ - public Observable> window(long timespan, TimeUnit unit) { - return create(OperationWindow.window(this, timespan, unit)); - } - - /** - * Creates an Observable which produces windows of collected values. This Observable produces connected - * non-overlapping windows, each of a fixed duration specified by the "timespan" argument. When the source - * Observable completes or encounters an error, the current window is emitted and the event is propagated. - * - * @param timespan - * The period of time each window is collecting values before it should be emitted, and - * replaced with a new window. - * @param unit - * The unit of time which applies to the "timespan" argument. - * @param scheduler - * The {@link Scheduler} to use when determining the end and start of a window. - * @return - * An {@link Observable} which produces connected non-overlapping windows with a fixed duration. - */ - public Observable> window(long timespan, TimeUnit unit, Scheduler scheduler) { - return create(OperationWindow.window(this, timespan, unit, scheduler)); - } - - /** - * Creates an Observable which produces windows of collected values. This Observable produces connected - * non-overlapping windows, each of a fixed duration specified by the "timespan" argument or a maximum size - * specified by the "count" argument (which ever is reached first). When the source Observable completes - * or encounters an error, the current window is emitted and the event is propagated. - * - * @param timespan - * The period of time each window is collecting values before it should be emitted, and - * replaced with a new window. - * @param unit - * The unit of time which applies to the "timespan" argument. - * @param count - * The maximum size of each window before it should be emitted. - * @return - * An {@link Observable} which produces connected non-overlapping windows which are emitted after - * a fixed duration or when the window has reached maximum capacity (which ever occurs first). - */ - public Observable> window(long timespan, TimeUnit unit, int count) { - return create(OperationWindow.window(this, timespan, unit, count)); - } - - /** - * Creates an Observable which produces windows of collected values. This Observable produces connected - * non-overlapping windows, each of a fixed duration specified by the "timespan" argument or a maximum size - * specified by the "count" argument (which ever is reached first). When the source Observable completes - * or encounters an error, the current window is emitted and the event is propagated. - * - * @param timespan - * The period of time each window is collecting values before it should be emitted, and - * replaced with a new window. - * @param unit - * The unit of time which applies to the "timespan" argument. - * @param count - * The maximum size of each window before it should be emitted. - * @param scheduler - * The {@link Scheduler} to use when determining the end and start of a window. - * @return - * An {@link Observable} which produces connected non-overlapping windows which are emitted after - * a fixed duration or when the window has reached maximum capacity (which ever occurs first). - */ - public Observable> window(long timespan, TimeUnit unit, int count, Scheduler scheduler) { - return create(OperationWindow.window(this, timespan, unit, count, scheduler)); - } - - /** - * Creates an Observable which produces windows of collected values. This Observable starts a new window - * periodically, which is determined by the "timeshift" argument. Each window is emitted after a fixed timespan - * specified by the "timespan" argument. When the source Observable completes or encounters an error, the - * current window is emitted and the event is propagated. - * - * @param timespan - * The period of time each window is collecting values before it should be emitted. - * @param timeshift - * The period of time after which a new window will be created. - * @param unit - * The unit of time which applies to the "timespan" and "timeshift" argument. - * @return - * An {@link Observable} which produces new windows periodically, and these are emitted after - * a fixed timespan has elapsed. - */ - public Observable> window(long timespan, long timeshift, TimeUnit unit) { - return create(OperationWindow.window(this, timespan, timeshift, unit)); - } - - /** - * Creates an Observable which produces windows of collected values. This Observable starts a new window - * periodically, which is determined by the "timeshift" argument. Each window is emitted after a fixed timespan - * specified by the "timespan" argument. When the source Observable completes or encounters an error, the - * current window is emitted and the event is propagated. - * - * @param timespan - * The period of time each window is collecting values before it should be emitted. - * @param timeshift - * The period of time after which a new window will be created. - * @param unit - * The unit of time which applies to the "timespan" and "timeshift" argument. - * @param scheduler - * The {@link Scheduler} to use when determining the end and start of a window. - * @return - * An {@link Observable} which produces new windows periodically, and these are emitted after - * a fixed timespan has elapsed. - */ - public Observable> window(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) { - return create(OperationWindow.window(this, timespan, timeshift, unit, scheduler)); - } - - /** - * Returns an Observable that emits the results of a function of your choosing applied to - * combinations of N items emitted, in sequence, by N other Observables as provided by an Iterable. - * - *

{@code zip} applies this function in strict sequence, so the first item emitted by the - * new Observable will be the result of the function applied to the first item emitted by - * all of the Observalbes; the second item emitted by the new Observable will be the result of - * the function applied to the second item emitted by each of those Observables; and so forth. - *

- * The resulting {@code Observable} returned from {@code zip} will invoke {@code onNext} as many times as the number of {@code onNext} invokations of the - * source Observable that emits the fewest items. - *

- * - * - * @param ws - * An Observable of source Observables - * @param zipFunction - * a function that, when applied to an item emitted by each of the source - * Observables, results in an item that will be emitted by the resulting Observable - * @return an Observable that emits the zipped results - */ - public static Observable zip(Observable> ws, final FuncN zipFunction) { - return ws.toList().mapMany(new Func1>, Observable>() { - @Override - public Observable call(List> wsList) { - return create(OperationZip.zip(wsList, zipFunction)); - } - }); - } - - /** - * Returns an Observable that emits the results of a function of your choosing applied to - * combinations of four items emitted, in sequence, by four other Observables. - *

{@code zip} applies this function in strict sequence, so the first item emitted by the - * new Observable will be the result of the function applied to the first item emitted by - * all of the Observalbes; the second item emitted by the new Observable will be the result of - * the function applied to the second item emitted by each of those Observables; and so forth. - *

- * The resulting {@code Observable} returned from {@code zip} will invoke {@code onNext} as many times as the number of {@code onNext} invokations of the - * source Observable that emits the fewest items. - *

- * - * - * @param ws - * A collection of source Observables - * @param zipFunction - * a function that, when applied to an item emitted by each of the source - * Observables, results in an item that will be emitted by the resulting Observable - * @return an Observable that emits the zipped results - */ - public static Observable zip(Iterable> ws, FuncN zipFunction) { - return create(OperationZip.zip(ws, zipFunction)); - } - - /** - *

- * - * - * @param predicate - * a function that evaluates the items emitted by the source Observable, returning {@code true} if they pass the filter - * @return an Observable that emits only those items in the original Observable that the filter - * evaluates as {@code true} - */ - public Observable filter(Func1 predicate) { - return create(OperationFilter.filter(this, predicate)); - } - - /** - * Registers an {@link Action0} to be called when this Observable invokes {@link Observer#onCompleted onCompleted} or {@link Observer#onError onError}. - *

- * - * - * @param action - * an {@link Action0} to be invoked when the source Observable finishes - * @return an Observable that emits the same items as the source Observable, then invokes the {@link Action0} - * @see MSDN: Observable.Finally Method - */ - public Observable finallyDo(Action0 action) { - return create(OperationFinally.finallyDo(this, action)); - } - - /** - * Creates a new Observable by applying a function that you supply to each item emitted by - * the source Observable, where that function returns an Observable, and then merging those - * resulting Observables and emitting the results of this merger. - *

- * - *

- * Note: {@code mapMany} and {@code flatMap} are equivalent. - * - * @param func - * a function that, when applied to an item emitted by the source Observable, returns - * an Observable - * @return an Observable that emits the result of applying the transformation function to each - * item emitted by the source Observable and merging the results of the Observables - * obtained from this transformation. - * @see #mapMany(Func1) - */ - public Observable flatMap(Func1> func) { - return mapMany(func); - } - - /** - *

- * - * - * @param predicate - * a function that evaluates an item emitted by the source Observable, returning {@code true} if it passes the filter - * @return an Observable that emits only those items in the original Observable that the filter - * evaluates as {@code true} - * @see #filter(Func1) - */ - public Observable where(Func1 predicate) { - return filter(predicate); - } - - /** - * Returns an Observable that applies the given function to each item emitted by an - * Observable and emits the result. - *

- * - * - * @param func - * a function to apply to each item emitted by the Observable - * @return an Observable that emits the items from the source Observable, transformed by the - * given function - */ - public Observable map(Func1 func) { - return create(OperationMap.map(this, func)); - } - - /** - * Creates a new Observable by applying a function that you supply to each item emitted by - * the source Observable, where that function returns an Observable, and then merging those - * resulting Observables and emitting the results of this merger. - *

- * - *

- * Note: mapMany and flatMap are equivalent. - * - * @param func - * a function that, when applied to an item emitted by the source Observable, returns - * an Observable - * @return an Observable that emits the result of applying the transformation function to each - * item emitted by the source Observable and merging the results of the Observables - * obtained from this transformation. - * @see #flatMap(Func1) - */ - public Observable mapMany(Func1> func) { - return create(OperationMap.mapMany(this, func)); - } - - /** - * Turns all of the notifications from a source Observable into {@link Observer#onNext onNext} emissions, and marks them with their original notification types within {@link Notification} objects. - *

- * - * - * @return an Observable whose items are the result of materializing the items and - * notifications of the source Observable - * @see MSDN: Observable.materialize - */ - public Observable> materialize() { - return create(OperationMaterialize.materialize(this)); - } - - /** - * Asynchronously subscribes and unsubscribes Observers on the specified {@link Scheduler}. - *

- * - * - * @param scheduler - * the {@link Scheduler} to perform subscription and unsubscription actions on - * @return the source Observable modified so that its subscriptions and unsubscriptions happen - * on the specified {@link Scheduler} - */ - public Observable subscribeOn(Scheduler scheduler) { - return create(OperationSubscribeOn.subscribeOn(this, scheduler)); - } - - /** - * Asynchronously notify {@link Observer}s on the specified {@link Scheduler}. - *

- * - * - * @param scheduler - * the {@link Scheduler} to notify {@link Observer}s on - * @return the source Observable modified so that its {@link Observer}s are notified on the - * specified {@link Scheduler} - */ - public Observable observeOn(Scheduler scheduler) { - return create(OperationObserveOn.observeOn(this, scheduler)); - } - - /** - * Returns an Observable that reverses the effect of {@link #materialize materialize} by - * transforming the {@link Notification} objects emitted by the source Observable into the items - * or notifications they represent. - *

- * - * - * @return an Observable that emits the items and notifications embedded in the {@link Notification} objects emitted by the source Observable - * @see MSDN: Observable.dematerialize - * @throws Throwable - * if the source Observable is not of type {@code Observable>}. - */ - @SuppressWarnings("unchecked") - public Observable dematerialize() { - return create(OperationDematerialize.dematerialize((Observable>) this)); - } - - /** - * Instruct an Observable to pass control to another Observable rather than invoking {@link Observer#onError onError} if it encounters an error. - *

- * - *

- * By default, when an Observable encounters an error that prevents it from emitting the - * expected item to its {@link Observer}, the Observable 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 Observable (resumeFunction) to - * onErrorResumeNext, if the original Observable encounters an error, instead of - * invoking its Observer's onError method, it will instead relinquish control to - * the Observable returned from resumeFunction, which will invoke the Observer's {@link Observer#onNext onNext} method if it is able to do so. In such a case, because no - * Observable 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. - * - * @param resumeFunction - * a function that returns an Observable that will take over if the source Observable - * encounters an error - * @return the original Observable, with appropriately modified behavior - */ - public Observable onErrorResumeNext(final Func1> resumeFunction) { - return create(OperationOnErrorResumeNextViaFunction.onErrorResumeNextViaFunction(this, resumeFunction)); - } - - /** - * Instruct an Observable to pass control to another Observable rather than invoking {@link Observer#onError onError} if it encounters an error. - *

- * - *

- * By default, when an Observable encounters an error that prevents it from emitting the - * expected item to its {@link Observer}, the Observable 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 - * another Observable (resumeSequence) to an Observable's - * onErrorResumeNext method, if the original Observable encounters an error, - * instead of invoking its Observer's onError method, it will instead relinquish - * control to resumeSequence which will invoke the Observer's {@link Observer#onNext onNext} method if it is able to do so. In such a case, because no - * Observable 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. - * - * @param resumeSequence - * a function that returns an Observable that will take over if the source Observable - * encounters an error - * @return the original Observable, with appropriately modified behavior - */ - public Observable onErrorResumeNext(final Observable resumeSequence) { - return create(OperationOnErrorResumeNextViaObservable.onErrorResumeNextViaObservable(this, resumeSequence)); - } - - /** - * Instruct an Observable to pass control to another Observable rather than invoking {@link Observer#onError onError} if it encounters an error of type {@link java.lang.Exception}. - *

- * This differs from {@link #onErrorResumeNext} in that this one does not handle {@link java.lang.Throwable} or {@link java.lang.Error} but lets those continue through. - *

- * - *

- * By default, when an Observable encounters an error that prevents it from emitting the - * expected item to its {@link Observer}, the Observable 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 - * another Observable (resumeSequence) to an Observable's - * onErrorResumeNext method, if the original Observable encounters an error, - * instead of invoking its Observer's onError method, it will instead relinquish - * control to resumeSequence which will invoke the Observer's {@link Observer#onNext onNext} method if it is able to do so. In such a case, because no - * Observable 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. - * - * @param resumeSequence - * a function that returns an Observable that will take over if the source Observable - * encounters an error - * @return the original Observable, with appropriately modified behavior - */ - public Observable onExceptionResumeNext(final Observable resumeSequence) { - return create(OperationOnExceptionResumeNextViaObservable.onExceptionResumeNextViaObservable(this, resumeSequence)); - } - - /** - * Instruct an Observable to emit an item (returned by a specified function) rather than - * invoking {@link Observer#onError onError} if it encounters an error. - *

- * - *

- * By default, when an Observable encounters an error that prevents it from emitting the - * expected item to its {@link Observer}, the Observable 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 Observable's onErrorReturn method, if the - * original Observable encounters an error, instead of invoking its Observer's - * onError method, it will instead pass the return value of - * resumeFunction to the Observer's {@link Observer#onNext onNext} method. - *

- * You can use this to prevent errors from propagating or to supply fallback data should errors - * be encountered. - * - * @param resumeFunction - * a function that returns an item that the new Observable will emit if the source - * Observable encounters an error - * @return the original Observable with appropriately modified behavior - */ - public Observable onErrorReturn(Func1 resumeFunction) { - return create(OperationOnErrorReturn.onErrorReturn(this, resumeFunction)); - } - - /** - * Returns an Observable that applies a function of your choosing to the first item emitted by a - * source Observable, then feeds the result of that function along with the second item emitted - * by the source Observable into the same function, and so on until all items have been emitted - * by the source Observable, and emits the final result from the final call to your function as - * its sole item. - *

- * - *

- * This technique, which is called "reduce" or "aggregate" here, is sometimes called "fold," - * "accumulate," "compress," or "inject" in other programming contexts. Groovy, for instance, - * has an inject method that does a similar operation on lists. - * - * @param accumulator - * An accumulator function to be invoked on each item emitted by the source - * Observable, whose result will be used in the next accumulator call - * @return an Observable that emits a single item that is the result of accumulating the - * output from the source Observable - * @see MSDN: Observable.Aggregate - * @see Wikipedia: Fold (higher-order function) - */ - public Observable reduce(Func2 accumulator) { - return create(OperationScan.scan(this, accumulator)).takeLast(1); - } - - /** - * Returns an Observable that counts the total number of elements in the source Observable. - * @return an Observable emitting the number of counted elements of the source Observable - * as its single item. - * @see MSDN: Observable.Count - */ - public Observable count() { - return reduce(0, new Func2() { - @Override - public Integer call(Integer t1, T t2) { - return t1 + 1; - } - }); - } - - /** - * Returns an Observable that sums up the elements in the source Observable. - * @param source - * Source observable to compute the sum of. - * @return an Observable emitting the sum of all the elements of the source Observable - * as its single item. - * @see MSDN: Observable.Sum - */ - public static Observable sum(Observable source) { - return OperationSum.sum(source); - } - - /** - * @see #sum(Observable) - * @see MSDN: Observable.Sum - */ - public static Observable sumLongs(Observable source) { - return OperationSum.sumLongs(source); - } - - /** - * @see #sum(Observable) - * @see MSDN: Observable.Sum - */ - public static Observable sumFloats(Observable source) { - return OperationSum.sumFloats(source); - } - - /** - * @see #sum(Observable) - * @see MSDN: Observable.Sum - */ - public static Observable sumDoubles(Observable source) { - return OperationSum.sumDoubles(source); - } - - /** - * Returns an Observable that computes the average of all elements in the source Observable. - * For an empty source, it causes an ArithmeticException. - * @param source - * Source observable to compute the average of. - * @return an Observable emitting the averageof all the elements of the source Observable - * as its single item. - * @see MSDN: Observable.Average - */ - public static Observable average(Observable source) { - return OperationAverage.average(source); - } - - /** - * @see #average(Observable) - * @see MSDN: Observable.Average - */ - public static Observable averageLongs(Observable source) { - return OperationAverage.averageLongs(source); - } - - /** - * @see #average(Observable) - * @see MSDN: Observable.Average - */ - public static Observable averageFloats(Observable source) { - return OperationAverage.averageFloats(source); - } - - /** - * @see #average(Observable) - * @see MSDN: Observable.Average - */ - public static Observable averageDoubles(Observable source) { - return OperationAverage.averageDoubles(source); - } - - /** - * Returns a {@link ConnectableObservable} that shares a single subscription to the underlying - * Observable that will replay all of its items and notifications to any future {@link Observer}. - *

- * - * - * @return a {@link ConnectableObservable} that upon connection causes the source Observable to - * emit items to its {@link Observer}s - */ - public ConnectableObservable replay() { - return OperationMulticast.multicast(this, ReplaySubject. create()); - } - - /** - * Retry subscription to origin Observable upto given retry count. - *

- * If {@link Observer#onError} is invoked the source Observable will be re-subscribed to as many times as defined by retryCount. - *

- * Any {@link Observer#onNext} calls received on each attempt will be emitted and concatenated together. - *

- * For example, if an Observable fails on first time but emits [1, 2] then succeeds the second time and - * emits [1, 2, 3, 4, 5] then the complete output would be [1, 2, 1, 2, 3, 4, 5, onCompleted]. - * - * @param retryCount - * Number of retry attempts before failing. - * @return Observable with retry logic. - */ - public Observable retry(int retryCount) { - return create(OperationRetry.retry(this, retryCount)); - } - - /** - * Retry subscription to origin Observable whenever onError is called (infinite retry count). - *

- * If {@link Observer#onError} is invoked the source Observable will be re-subscribed to. - *

- * Any {@link Observer#onNext} calls received on each attempt will be emitted and concatenated together. - *

- * For example, if an Observable fails on first time but emits [1, 2] then succeeds the second time and - * emits [1, 2, 3, 4, 5] then the complete output would be [1, 2, 1, 2, 3, 4, 5, onCompleted]. - * - * @param retryCount - * Number of retry attempts before failing. - * @return Observable with retry logic. - */ - public Observable retry() { - return create(OperationRetry.retry(this)); - } - - /** - * This method has similar behavior to {@link #replay} except that this auto-subscribes to - * the source Observable rather than returning a {@link ConnectableObservable}. - *

- * - *

- * This is useful when you want an Observable to cache responses and you can't control the - * subscribe/unsubscribe behavior of all the {@link Observer}s. - *

- * NOTE: You sacrifice the ability to unsubscribe from 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. - * - * @return an Observable that when first subscribed to, caches all of its notifications for - * the benefit of subsequent subscribers. - */ - public Observable cache() { - return create(OperationCache.cache(this)); - } - - /** - * Returns a {@link ConnectableObservable}, which waits until its {@link ConnectableObservable#connect connect} method is called before it begins emitting - * items to those {@link Observer}s that have subscribed to it. - *

- * - * - * @return a {@link ConnectableObservable} that upon connection causes the source Observable to - * emit items to its {@link Observer}s - */ - public ConnectableObservable publish() { - return OperationMulticast.multicast(this, PublishSubject. create()); - } - - /** - * Synonymous with reduce(). - *

- * - * - * @see #reduce(Func2) - */ - public Observable aggregate(Func2 accumulator) { - return reduce(accumulator); - } - - /** - * Returns an Observable that applies a function of your choosing to the first item emitted by a - * source Observable, then feeds the result of that function along with the second item emitted - * by an Observable into the same function, and so on until all items have been emitted by the - * source Observable, emitting the final result from the final call to your function as its sole - * item. - *

- * - *

- * This technique, which is called "reduce" or "aggregate" here, is sometimes called "fold," - * "accumulate," "compress," or "inject" in other programming contexts. Groovy, for instance, - * has an inject method that does a similar operation on lists. - * - * @param initialValue - * the initial (seed) accumulator value - * @param accumulator - * an accumulator function to be invoked on each item emitted by the source - * Observable, the result of which will be used in the next accumulator call - * @return an Observable that emits a single item that is the result of accumulating the output - * from the items emitted by the source Observable - * @see MSDN: Observable.Aggregate - * @see Wikipedia: Fold (higher-order function) - */ - public Observable reduce(R initialValue, Func2 accumulator) { - return create(OperationScan.scan(this, initialValue, accumulator)).takeLast(1); - } - - /** - * Synonymous with reduce(). - *

- * - * - * @see #reduce(Object, Func2) - */ - public Observable aggregate(R initialValue, Func2 accumulator) { - return reduce(initialValue, accumulator); - } - - /** - * Returns an Observable that applies a function of your choosing to the first item emitted by a - * source Observable, then feeds the result of that function along with the second item emitted - * by an Observable into the same function, and so on until all items have been emitted by the - * source Observable, emitting the result of each of these iterations. - *

- * - *

- * This sort of function is sometimes called an accumulator. - *

- * Note that when you pass a seed to scan() the resulting Observable will emit - * that seed as its first emitted item. - * - * @param accumulator - * an accumulator function to be invoked on each item emitted by the source - * Observable, whose result will be emitted to {@link Observer}s via {@link Observer#onNext onNext} and used in the next accumulator call. - * @return an Observable that emits the results of each call to the accumulator function - * @see MSDN: Observable.Scan - */ - public Observable scan(Func2 accumulator) { - return create(OperationScan.scan(this, accumulator)); - } - - /** - * Returns an Observable that emits the results of sampling the items emitted by the source - * Observable at a specified time interval. - *

- * - * - * @param period - * the sampling rate - * @param unit - * the {@link TimeUnit} in which period is defined - * @return an Observable that emits the results of sampling the items emitted by the source - * Observable at the specified time interval - */ - public Observable sample(long period, TimeUnit unit) { - return create(OperationSample.sample(this, period, unit)); - } - - /** - * Returns an Observable that emits the results of sampling the items emitted by the source - * Observable at a specified time interval. - *

- * - * - * @param period - * the sampling rate - * @param unit - * the {@link TimeUnit} in which period is defined - * @param scheduler - * the {@link Scheduler} to use when sampling - * @return an Observable that emits the results of sampling the items emitted by the source - * Observable at the specified time interval - */ - public Observable sample(long period, TimeUnit unit, Scheduler scheduler) { - return create(OperationSample.sample(this, period, unit, scheduler)); - } - - /** - * Returns an Observable that applies a function of your choosing to the first item emitted by a - * source Observable, then feeds the result of that function along with the second item emitted - * by an Observable into the same function, and so on until all items have been emitted by the - * source Observable, emitting the result of each of these iterations. - *

- * - *

- * This sort of function is sometimes called an accumulator. - *

- * Note that when you pass a seed to scan() the resulting Observable will emit - * that seed as its first emitted item. - * - * @param initialValue - * the initial (seed) accumulator value - * @param accumulator - * an accumulator function to be invoked on each item emitted by the source - * Observable, whose result will be emitted to {@link Observer}s via {@link Observer#onNext onNext} and used in the next accumulator call. - * @return an Observable that emits the results of each call to the accumulator function - * @see MSDN: Observable.Scan - */ - public Observable scan(R initialValue, Func2 accumulator) { - return create(OperationScan.scan(this, initialValue, accumulator)); - } - - /** - * Returns an Observable that emits a Boolean that indicates whether all of the items emitted by - * the source Observable satisfy a condition. - *

- * - * - * @param predicate - * a function that evaluates an item and returns a Boolean - * @return an Observable that emits true if all items emitted by the source - * Observable satisfy the predicate; otherwise, false - */ - public Observable all(Func1 predicate) { - return create(OperationAll.all(this, predicate)); - } - - /** - * Returns an Observable that skips the first num items emitted by the source - * Observable and emits the remainder. - *

- * - *

- * You can ignore the first num items emitted by an Observable and attend only to - * those items that come after, by modifying the Observable with the skip method. - * - * @param num - * the number of items to skip - * @return an Observable that is identical to the source Observable except that it does not - * emit the first num items that the source emits - */ - public Observable skip(int num) { - return create(OperationSkip.skip(this, num)); - } - - /** - * Returns an Observable that emits only the very first item emitted by the source Observable. - * - * @return an Observable that emits only the very first item from the source, or none if the - * source Observable completes without emitting a single item. - * @see MSDN: Observable.First - */ - public Observable first() { - return take(1); - } - - /** - * Returns an Observable that emits only the very first item emitted by the source Observable - * that satisfies a given condition. - * - * @param predicate - * The condition any source emitted item has to satisfy. - * @return an Observable that emits only the very first item satisfying the given condition from the source, - * or none if the source Observable completes without emitting a single matching item. - * @see MSDN: Observable.First - */ - public Observable first(Func1 predicate) { - return skipWhile(not(predicate)).take(1); - } - - /** - * Returns an Observable that emits only the very first item emitted by the source Observable, or - * a default value. - * - * @param defaultValue - * The default value to emit if the source Observable doesn't emit anything. - * @return an Observable that emits only the very first item from the source, or a default value - * if the source Observable completes without emitting a single item. - * @see MSDN: Observable.FirstOrDefault - */ - public Observable firstOrDefault(T defaultValue) { - return create(OperationFirstOrDefault.firstOrDefault(this, defaultValue)); - } - - /** - * Returns an Observable that emits only the very first item emitted by the source Observable - * that satisfies a given condition, or a default value otherwise. - * - * @param predicate - * The condition any source emitted item has to satisfy. - * @param defaultValue - * The default value to emit if the source Observable doesn't emit anything that - * satisfies the given condition. - * @return an Observable that emits only the very first item from the source that satisfies the - * given condition, or a default value otherwise. - * @see MSDN: Observable.FirstOrDefault - */ - public Observable firstOrDefault(Func1 predicate, T defaultValue) { - return create(OperationFirstOrDefault.firstOrDefault(this, predicate, defaultValue)); - } - - - /** - * Returns an Observable that emits only the first num items emitted by the source - * Observable. - *

- * - *

- * This method returns an Observable that will invoke a subscribing {@link Observer}'s {@link Observer#onNext onNext} function a maximum of num times before invoking - * {@link Observer#onCompleted onCompleted}. - * - * @param num - * the number of items to take - * @return an Observable that emits only the first num items from the source - * Observable, or all of the items from the source Observable if that Observable emits - * fewer than num items - */ - public Observable take(final int num) { - return create(OperationTake.take(this, num)); - } - - /** - * Returns an Observable that emits items emitted by the source Observable so long as a - * specified condition is true. - *

- * - * - * @param predicate - * a function that evaluates an item emitted by the source Observable and returns a - * Boolean - * @return an Observable that emits the items from the source Observable so long as each item - * satisfies the condition defined by predicate - */ - public Observable takeWhile(final Func1 predicate) { - return create(OperationTakeWhile.takeWhile(this, predicate)); - } - - /** - * Returns an Observable that emits the items emitted by a source Observable so long as a given - * predicate remains true, where the predicate can operate on both the item and its index - * relative to the complete sequence. - *

- * - * - * @param predicate - * a function to test each item emitted by the source Observable for a condition; - * the second parameter of the function represents the index of the source item - * @return an Observable that emits items from the source Observable so long as the predicate - * continues to return true for each item, then completes - */ - public Observable takeWhileWithIndex(final Func2 predicate) { - return create(OperationTakeWhile.takeWhileWithIndex(this, predicate)); - } - - /** - * Returns an Observable that emits only the very first item emitted by the source Observable. - * - * @return an Observable that emits only the very first item from the source, or none if the - * source Observable completes without emitting a single item. - * @see MSDN: Observable.First - * @see {@link #first()} - */ - public Observable takeFirst() { - return first(); - } - - /** - * Returns an Observable that emits only the very first item emitted by the source Observable - * that satisfies a given condition. - * - * @param predicate - * The condition any source emitted item has to satisfy. - * @return an Observable that emits only the very first item satisfying the given condition from the source, - * or none if the source Observable completes without emitting a single matching item. - * @see MSDN: Observable.First - * @see {@link #first(Func1)} - */ - public Observable takeFirst(Func1 predicate) { - return first(predicate); - } - - /** - * Returns an Observable that emits only the last count items emitted by the source - * Observable. - *

- * - * - * @param count - * the number of items to emit from the end of the sequence emitted by the source - * Observable - * @return an Observable that emits only the last count items emitted by the source - * Observable - */ - public Observable takeLast(final int count) { - return create(OperationTakeLast.takeLast(this, count)); - } - - /** - * Returns an Observable that emits the items from the source Observable only until the - * other Observable emits an item. - *

- * - * - * @param other - * the Observable whose first emitted item will cause takeUntil to stop - * emitting items from the source Observable - * @param - * the type of items emitted by other - * @return an Observable that emits the items of the source Observable until such time as - * other emits its first item - */ - public Observable takeUntil(Observable other) { - return OperationTakeUntil.takeUntil(this, other); - } - - /** - * Returns an Observable that bypasses all items from the source Observable as long as the specified - * condition holds true. Emits all further source items as soon as the condition becomes false. - * @param predicate - * A function to test each item emitted from the source Observable for a condition. - * It receives the emitted item as first parameter and the index of the emitted item as - * second parameter. - * @return an Observable that emits all items from the source Observable as soon as the condition - * becomes false. - * @see MSDN: Observable.SkipWhile - */ - public Observable skipWhileWithIndex(Func2 predicate) { - return create(OperationSkipWhile.skipWhileWithIndex(this, predicate)); - } - - /** - * Returns an Observable that bypasses all items from the source Observable as long as the specified - * condition holds true. Emits all further source items as soon as the condition becomes false. - * @param predicate - * A function to test each item emitted from the source Observable for a condition. - * @return an Observable that emits all items from the source Observable as soon as the condition - * becomes false. - * @see MSDN: Observable.SkipWhile - */ - public Observable skipWhile(Func1 predicate) { - return create(OperationSkipWhile.skipWhile(this, predicate)); - } - - /** - * Returns an Observable that emits a single item, a list composed of all the items emitted by - * the source Observable. - *

- * - *

- * Normally, an Observable that returns multiple items will do so by invoking its {@link Observer}'s {@link Observer#onNext onNext} method for each such item. You can change - * this behavior, instructing the Observable to compose a list of all of these items and then to - * invoke the Observer's onNext function once, passing it the entire list, by - * calling the Observable's toList method prior to calling its {@link #subscribe} method. - *

- * Be careful not to use this operator on Observables that emit infinite or very large numbers - * of items, as you do not have the option to unsubscribe. - * - * @return an Observable that emits a single item: a List containing all of the items emitted by - * the source Observable. - */ - public Observable> toList() { - return create(OperationToObservableList.toObservableList(this)); - } - - /** - * Return an Observable that emits the items emitted by the source Observable, in a sorted - * order (each item emitted by the Observable must implement {@link Comparable} with respect to - * all other items in the sequence). - *

- * - * - * @throws ClassCastException - * if any item emitted by the Observable does not implement {@link Comparable} with - * respect to all other items emitted by the Observable - * @return an Observable that emits the items from the source Observable in sorted order - */ - public Observable> toSortedList() { - return create(OperationToObservableSortedList.toSortedList(this)); - } - - /** - * Return an Observable that emits the items emitted by the source Observable, in a sorted - * order based on a specified comparison function - *

- * - * - * @param sortFunction - * a function that compares two items emitted by the source Observable and returns - * an Integer that indicates their sort order - * @return an Observable that emits the items from the source Observable in sorted order - */ - public Observable> toSortedList(Func2 sortFunction) { - return create(OperationToObservableSortedList.toSortedList(this, sortFunction)); - } - - /** - * Emit a specified set of items before beginning to emit items from the source Observable. - *

- * - * - * @param values - * Iterable of the items you want the modified Observable to emit first - * @return an Observable that exhibits the modified behavior - */ - public Observable startWith(Iterable values) { - return concat(Observable. from(values), this); - } - - /** - * Emit a specified set of items before beginning to emit items from the source Observable. - *

- * - * - * @param t1 - * item to include - * @param values - * Iterable of the items you want the modified Observable to emit first - * @return an Observable that exhibits the modified behavior - */ - public Observable startWith(T t1) { - return concat(Observable. from(t1), this); - } - - /** - * Emit a specified set of items before beginning to emit items from the source Observable. - *

- * - * - * @param t1 - * item to include - * @param t2 - * item to include - * @param values - * Iterable of the items you want the modified Observable to emit first - * @return an Observable that exhibits the modified behavior - */ - public Observable startWith(T t1, T t2) { - return concat(Observable. from(t1, t2), this); - } - - /** - * Emit a specified set of items before beginning to emit items from the source Observable. - *

- * - * - * @param t1 - * item to include - * @param t2 - * item to include - * @param t3 - * item to include - * @param values - * Iterable of the items you want the modified Observable to emit first - * @return an Observable that exhibits the modified behavior - */ - public Observable startWith(T t1, T t2, T t3) { - return concat(Observable. from(t1, t2, t3), this); - } - - /** - * Emit a specified set of items before beginning to emit items from the source Observable. - *

- * - * - * @param t1 - * item to include - * @param t2 - * item to include - * @param t3 - * item to include - * @param t4 - * item to include - * @param values - * Iterable of the items you want the modified Observable to emit first - * @return an Observable that exhibits the modified behavior - */ - public Observable startWith(T t1, T t2, T t3, T t4) { - return concat(Observable. from(t1, t2, t3, t4), this); - } - - /** - * Emit a specified set of items before beginning to emit items from the source Observable. - *

- * - * - * @param t1 - * item to include - * @param t2 - * item to include - * @param t3 - * item to include - * @param t4 - * item to include - * @param t5 - * item to include - * @param values - * Iterable of the items you want the modified Observable to emit first - * @return an Observable that exhibits the modified behavior - */ - public Observable startWith(T t1, T t2, T t3, T t4, T t5) { - return concat(Observable. from(t1, t2, t3, t4, t5), this); - } - - /** - * Emit a specified set of items before beginning to emit items from the source Observable. - *

- * - * - * @param t1 - * item to include - * @param t2 - * item to include - * @param t3 - * item to include - * @param t4 - * item to include - * @param t5 - * item to include - * @param t6 - * item to include - * @param values - * Iterable of the items you want the modified Observable to emit first - * @return an Observable that exhibits the modified behavior - */ - public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6) { - return concat(Observable. from(t1, t2, t3, t4, t5, t6), this); - } - - /** - * Emit a specified set of items before beginning to emit items from the source Observable. - *

- * - * - * @param t1 - * item to include - * @param t2 - * item to include - * @param t3 - * item to include - * @param t4 - * item to include - * @param t5 - * item to include - * @param t6 - * item to include - * @param t7 - * item to include - * @param values - * Iterable of the items you want the modified Observable to emit first - * @return an Observable that exhibits the modified behavior - */ - public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7) { - return concat(Observable. from(t1, t2, t3, t4, t5, t6, t7), this); - } - - /** - * Emit a specified set of items before beginning to emit items from the source Observable. - *

- * - * - * @param t1 - * item to include - * @param t2 - * item to include - * @param t3 - * item to include - * @param t4 - * item to include - * @param t5 - * item to include - * @param t6 - * item to include - * @param t7 - * item to include - * @param t8 - * item to include - * @param values - * Iterable of the items you want the modified Observable to emit first - * @return an Observable that exhibits the modified behavior - */ - public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8) { - return concat(Observable. from(t1, t2, t3, t4, t5, t6, t7, t8), this); - } - - /** - * Emit a specified set of items before beginning to emit items from the source Observable. - *

- * - * - * @param t1 - * item to include - * @param t2 - * item to include - * @param t3 - * item to include - * @param t4 - * item to include - * @param t5 - * item to include - * @param t6 - * item to include - * @param t7 - * item to include - * @param t8 - * item to include - * @param t9 - * item to include - * @param values - * Iterable of the items you want the modified Observable to emit first - * @return an Observable that exhibits the modified behavior - */ - public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9) { - return concat(Observable. from(t1, t2, t3, t4, t5, t6, t7, t8, t9), this); - } - - /** - * Groups the items emitted by an Observable according to a specified criterion, and emits these - * grouped items as {@link GroupedObservable}s, one GroupedObservable per group. - *

- * - * - * @param keySelector - * a function that extracts the key from an item - * @param elementSelector - * a function to map a source item to an item in a {@link GroupedObservable} - * @param - * the key type - * @param - * the type of items emitted by the resulting {@link GroupedObservable}s - * @return an Observable that emits {@link GroupedObservable}s, each of which corresponds to a - * unique key value and emits items representing items from the source Observable that - * share that key value - */ - public Observable> groupBy(final Func1 keySelector, final Func1 elementSelector) { - return create(OperationGroupBy.groupBy(this, keySelector, elementSelector)); - } - - /** - * Groups the items emitted by an Observable according to a specified criterion, and emits these - * grouped items as {@link GroupedObservable}s, one GroupedObservable per group. - *

- * - * - * @param keySelector - * a function that extracts the key for each item - * @param - * the key type - * @return an Observable that emits {@link GroupedObservable}s, each of which corresponds to a - * unique key value and emits items representing items from the source Observable that - * share that key value - */ - public Observable> groupBy(final Func1 keySelector) { - return create(OperationGroupBy.groupBy(this, keySelector)); - } - - /** - * Converts an Observable into a {@link BlockingObservable} (an Observable with blocking - * operators). - * - * @see Blocking Observable Operators - */ - public BlockingObservable toBlockingObservable() { - return BlockingObservable.from(this); - } - - /** - * Whether a given {@link Function} is an internal implementation inside rx.* packages or not. - *

- * For why this is being used see https://github.com/Netflix/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls to user code from within an operator" - * - * NOTE: If strong reasons for not depending on package names comes up then the implementation of this method can change to looking for a marker interface. -<<<<<<< HEAD - * -======= - * ->>>>>>> 128e598a9b4dafa4f03d65935bfad9c1e5467bfb - * @param o - * @return {@code true} if the given function is an internal implementation, and {@code false} otherwise. - */ - private boolean isInternalImplementation(Object o) { - if (o == null) { - return true; - } - // prevent double-wrapping (yeah it happens) - if (o instanceof SafeObserver) - return true; - // we treat the following package as "internal" and don't wrap it - Package p = o.getClass().getPackage(); // it can be null - return p != null && p.getName().startsWith("rx.operators"); - } - -} diff --git a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java index 1595c31195..c5970435e5 100644 --- a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java +++ b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java @@ -54,6 +54,15 @@ protected ConnectableObservable(OnSubscribeFunc onSubscribe) { * @return a {@link Observable} */ public Observable refCount() { - return Observable.create(OperationRefCount.refCount(this)); + return refCount(this); + } + + /** + * Returns an observable sequence that stays connected to the source as long + * as there is at least one subscription to the observable sequence. + * @return a {@link Observable} + */ + public static Observable refCount(ConnectableObservable that) { + return Observable.create(OperationRefCount.refCount(that)); } } diff --git a/rxjava-core/src/main/java/rx/operators/OperationRefCount.java b/rxjava-core/src/main/java/rx/operators/OperationRefCount.java index 97cb8f738f..4617f3ac40 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationRefCount.java +++ b/rxjava-core/src/main/java/rx/operators/OperationRefCount.java @@ -15,11 +15,6 @@ */ package rx.operators; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; -import org.mockito.MockitoAnnotations; import rx.Observable; import rx.Observer; import rx.Subscription; @@ -27,8 +22,6 @@ import rx.subscriptions.Subscriptions; import rx.util.functions.Action0; -import static org.mockito.Mockito.*; - /** * Returns an observable sequence that stays connected to the source as long * as there is at least one subscription to the observable sequence. @@ -69,78 +62,5 @@ public void call() { } }); } - - public static class UnitTest { - - @Before - public void setUp() { - MockitoAnnotations.initMocks(this); - } - - @Test - public void subscriptionToUnderlyingOnFirstSubscription() { - @SuppressWarnings("unchecked") - ConnectableObservable connectable = mock(ConnectableObservable.class); - Observable refCounted = Observable.create(refCount(connectable)); - @SuppressWarnings("unchecked") - Observer observer = mock(Observer.class); - when(connectable.subscribe(observer)).thenReturn(Subscriptions.empty()); - when(connectable.connect()).thenReturn(Subscriptions.empty()); - refCounted.subscribe(observer); - verify(connectable, times(1)).subscribe(observer); - verify(connectable, times(1)).connect(); - } - - @Test - public void noSubscriptionToUnderlyingOnSecondSubscription() { - @SuppressWarnings("unchecked") - ConnectableObservable connectable = mock(ConnectableObservable.class); - Observable refCounted = Observable.create(refCount(connectable)); - @SuppressWarnings("unchecked") - Observer observer = mock(Observer.class); - when(connectable.subscribe(observer)).thenReturn(Subscriptions.empty()); - when(connectable.connect()).thenReturn(Subscriptions.empty()); - refCounted.subscribe(observer); - refCounted.subscribe(observer); - verify(connectable, times(2)).subscribe(observer); - verify(connectable, times(1)).connect(); - } - - @Test - public void unsubscriptionFromUnderlyingOnLastUnsubscription() { - @SuppressWarnings("unchecked") - ConnectableObservable connectable = mock(ConnectableObservable.class); - Observable refCounted = Observable.create(refCount(connectable)); - @SuppressWarnings("unchecked") - Observer observer = mock(Observer.class); - Subscription underlying = mock(Subscription.class); - when(connectable.subscribe(observer)).thenReturn(underlying); - Subscription connection = mock(Subscription.class); - when(connectable.connect()).thenReturn(connection); - Subscription first = refCounted.subscribe(observer); - first.unsubscribe(); - verify(underlying, times(1)).unsubscribe(); - verify(connection, times(1)).unsubscribe(); - } - - @Test - public void noUnsubscriptionFromUnderlyingOnFirstUnsubscription() { - @SuppressWarnings("unchecked") - ConnectableObservable connectable = mock(ConnectableObservable.class); - Observable refCounted = Observable.create(refCount(connectable)); - @SuppressWarnings("unchecked") - Observer observer = mock(Observer.class); - Subscription underlying = mock(Subscription.class); - when(connectable.subscribe(observer)).thenReturn(underlying); - Subscription connection = mock(Subscription.class); - when(connectable.connect()).thenReturn(connection); - Subscription first = refCounted.subscribe(observer); - Subscription second = refCounted.subscribe(observer); - first.unsubscribe(); - second.unsubscribe(); - verify(underlying, times(2)).unsubscribe(); - verify(connection, times(1)).unsubscribe(); - } - } } } \ No newline at end of file diff --git a/rxjava-core/src/test/java/rx/RefCountTests.java b/rxjava-core/src/test/java/rx/RefCountTests.java new file mode 100644 index 0000000000..dae95bf265 --- /dev/null +++ b/rxjava-core/src/test/java/rx/RefCountTests.java @@ -0,0 +1,82 @@ +package rx; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.MockitoAnnotations; +import rx.observables.ConnectableObservable; +import rx.subscriptions.Subscriptions; + +import static org.mockito.Mockito.*; + +public class RefCountTests { + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + } + + @Test + public void subscriptionToUnderlyingOnFirstSubscription() { + @SuppressWarnings("unchecked") + ConnectableObservable connectable = mock(ConnectableObservable.class); + Observable refCounted = ConnectableObservable.refCount(connectable); + @SuppressWarnings("unchecked") + Observer observer = mock(Observer.class); + when(connectable.subscribe(any(Observer.class))).thenReturn(Subscriptions.empty()); + when(connectable.connect()).thenReturn(Subscriptions.empty()); + refCounted.subscribe(observer); + verify(connectable, times(1)).subscribe(any(Observer.class)); + verify(connectable, times(1)).connect(); + } + + @Test + public void noSubscriptionToUnderlyingOnSecondSubscription() { + @SuppressWarnings("unchecked") + ConnectableObservable connectable = mock(ConnectableObservable.class); + Observable refCounted = ConnectableObservable.refCount(connectable); + @SuppressWarnings("unchecked") + Observer observer = mock(Observer.class); + when(connectable.subscribe(any(Observer.class))).thenReturn(Subscriptions.empty()); + when(connectable.connect()).thenReturn(Subscriptions.empty()); + refCounted.subscribe(observer); + refCounted.subscribe(observer); + verify(connectable, times(2)).subscribe(any(Observer.class)); + verify(connectable, times(1)).connect(); + } + + @Test + public void unsubscriptionFromUnderlyingOnLastUnsubscription() { + @SuppressWarnings("unchecked") + ConnectableObservable connectable = mock(ConnectableObservable.class); + Observable refCounted = ConnectableObservable.refCount(connectable); + @SuppressWarnings("unchecked") + Observer observer = mock(Observer.class); + Subscription underlying = mock(Subscription.class); + when(connectable.subscribe(any(Observer.class))).thenReturn(underlying); + Subscription connection = mock(Subscription.class); + when(connectable.connect()).thenReturn(connection); + Subscription first = refCounted.subscribe(observer); + first.unsubscribe(); + verify(underlying, times(1)).unsubscribe(); + verify(connection, times(1)).unsubscribe(); + } + + @Test + public void noUnsubscriptionFromUnderlyingOnFirstUnsubscription() { + @SuppressWarnings("unchecked") + ConnectableObservable connectable = mock(ConnectableObservable.class); + Observable refCounted = ConnectableObservable.refCount(connectable); + @SuppressWarnings("unchecked") + Observer observer = mock(Observer.class); + Subscription underlying = mock(Subscription.class); + when(connectable.subscribe(any(Observer.class))).thenReturn(underlying); + Subscription connection = mock(Subscription.class); + when(connectable.connect()).thenReturn(connection); + Subscription first = refCounted.subscribe(observer); + Subscription second = refCounted.subscribe(observer); + first.unsubscribe(); + second.unsubscribe(); + verify(underlying, times(2)).unsubscribe(); + verify(connection, times(1)).unsubscribe(); + } +} From 63ae2b19de891e021dae2497f6829b70494475c6 Mon Sep 17 00:00:00 2001 From: John Marks Date: Tue, 24 Sep 2013 12:11:49 +0100 Subject: [PATCH 5/9] Finished RefCount - all tests pass --- .../src/main/java/rx/observables/ConnectableObservable.java | 1 + 1 file changed, 1 insertion(+) diff --git a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java index c5970435e5..a208673028 100644 --- a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java +++ b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java @@ -61,6 +61,7 @@ public Observable refCount() { * Returns an observable sequence that stays connected to the source as long * as there is at least one subscription to the observable sequence. * @return a {@link Observable} + * @param that a {@link ConnectableObservable} */ public static Observable refCount(ConnectableObservable that) { return Observable.create(OperationRefCount.refCount(that)); From 1402dbfed5b8768992d95b227b852b4338b6b5fc Mon Sep 17 00:00:00 2001 From: John Marks Date: Tue, 24 Sep 2013 12:22:02 +0100 Subject: [PATCH 6/9] Removed classes dir --- .../rxjava-core/rx/operators/README.txt | 5 ---- .../rxjava-core/rx/operators/package.html | 23 ------------------- classes/test/rxjava-core/README.md | 8 ------- .../test/rxjava-core/rx/operators/README.txt | 5 ---- .../rxjava-core/rx/operators/package.html | 23 ------------------- 5 files changed, 64 deletions(-) delete mode 100644 classes/production/rxjava-core/rx/operators/README.txt delete mode 100644 classes/production/rxjava-core/rx/operators/package.html delete mode 100644 classes/test/rxjava-core/README.md delete mode 100644 classes/test/rxjava-core/rx/operators/README.txt delete mode 100644 classes/test/rxjava-core/rx/operators/package.html diff --git a/classes/production/rxjava-core/rx/operators/README.txt b/classes/production/rxjava-core/rx/operators/README.txt deleted file mode 100644 index c2d441a10c..0000000000 --- a/classes/production/rxjava-core/rx/operators/README.txt +++ /dev/null @@ -1,5 +0,0 @@ -This package "rx.operators" is for internal implementation details and can change at any time. - -It is excluded from the public Javadocs (http://netflix.github.io/RxJava/javadoc/) and should not be relied upon by any code. - -In short, changes to public signatures of these classes will not be accounted for in the versioning of RxJava. \ No newline at end of file diff --git a/classes/production/rxjava-core/rx/operators/package.html b/classes/production/rxjava-core/rx/operators/package.html deleted file mode 100644 index 80ba7542bf..0000000000 --- a/classes/production/rxjava-core/rx/operators/package.html +++ /dev/null @@ -1,23 +0,0 @@ - - -

Operators that allow composing Observables to transform and - manipulate data in an asynchronous, functional and thread-safe manner.

-

The operators are all exposed via the ObservableExtensions class

- - \ No newline at end of file diff --git a/classes/test/rxjava-core/README.md b/classes/test/rxjava-core/README.md deleted file mode 100644 index 74b6c91536..0000000000 --- a/classes/test/rxjava-core/README.md +++ /dev/null @@ -1,8 +0,0 @@ -This test folder only contains performance and functional/integration style tests. - -The unit tests themselves are embedded as inner classes of the Java code (such as here: [rxjava-core/src/main/java/rx/operators](https://github.com/Netflix/RxJava/tree/master/rxjava-core/src/main/java/rx/operators)). - -* For an explanation of this design choice see -Ben J. Christensen's [JUnit Tests as Inner Classes](http://benjchristensen.com/2011/10/23/junit-tests-as-inner-classes/). - -Also, each of the language adaptors has a /src/test/ folder which further testing (see Groovy for an example: [language-adaptors/rxjava-groovy/src/test](https://github.com/Netflix/RxJava/tree/master/language-adaptors/rxjava-groovy/src/test)). diff --git a/classes/test/rxjava-core/rx/operators/README.txt b/classes/test/rxjava-core/rx/operators/README.txt deleted file mode 100644 index c2d441a10c..0000000000 --- a/classes/test/rxjava-core/rx/operators/README.txt +++ /dev/null @@ -1,5 +0,0 @@ -This package "rx.operators" is for internal implementation details and can change at any time. - -It is excluded from the public Javadocs (http://netflix.github.io/RxJava/javadoc/) and should not be relied upon by any code. - -In short, changes to public signatures of these classes will not be accounted for in the versioning of RxJava. \ No newline at end of file diff --git a/classes/test/rxjava-core/rx/operators/package.html b/classes/test/rxjava-core/rx/operators/package.html deleted file mode 100644 index 80ba7542bf..0000000000 --- a/classes/test/rxjava-core/rx/operators/package.html +++ /dev/null @@ -1,23 +0,0 @@ - - -

Operators that allow composing Observables to transform and - manipulate data in an asynchronous, functional and thread-safe manner.

-

The operators are all exposed via the ObservableExtensions class

- - \ No newline at end of file From e0f57f17cc18ff4d2824984afa648e4ebdf6bc4b Mon Sep 17 00:00:00 2001 From: John Marks Date: Tue, 24 Sep 2013 12:23:13 +0100 Subject: [PATCH 7/9] Minor tweak --- rxjava-core/src/main/java/rx/Observable.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 4d40ce4350..64fdf2ad62 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -4339,7 +4339,7 @@ public BlockingObservable toBlockingObservable() { * * NOTE: If strong reasons for not depending on package names comes up then the implementation of this method can change to looking for a marker interface. * - * @param f + * @param o * @return {@code true} if the given function is an internal implementation, and {@code false} otherwise. */ private boolean isInternalImplementation(Object o) { From d4b04d88396bfd0e3932e5c53219cf40adc7fb81 Mon Sep 17 00:00:00 2001 From: John Marks Date: Tue, 24 Sep 2013 13:01:25 +0100 Subject: [PATCH 8/9] Implemented publishLast --- rxjava-core/src/main/java/rx/Observable.java | 9 ++++ .../src/test/java/rx/ObservableTests.java | 42 +++++++++++++++++++ 2 files changed, 51 insertions(+) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 64fdf2ad62..d72201accb 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -83,6 +83,7 @@ import rx.plugins.RxJavaErrorHandler; import rx.plugins.RxJavaObservableExecutionHook; import rx.plugins.RxJavaPlugins; +import rx.subjects.AsyncSubject; import rx.subjects.PublishSubject; import rx.subjects.ReplaySubject; import rx.subjects.Subject; @@ -3634,6 +3635,14 @@ public ConnectableObservable publish() { return OperationMulticast.multicast(this, PublishSubject. create()); } + /** + * Returns a {@link ConnectableObservable} that shares a single subscription that contains the last notification only. + * @return a {@link ConnectableObservable} + */ + public ConnectableObservable publishLast() { + return OperationMulticast.multicast(this, AsyncSubject. create()); + } + /** * Synonymous with reduce(). *

diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java index 92af02b1dd..d70a5de8ce 100644 --- a/rxjava-core/src/test/java/rx/ObservableTests.java +++ b/rxjava-core/src/test/java/rx/ObservableTests.java @@ -487,6 +487,48 @@ public void call(String v) { } } + @Test + public void testPublishLast() throws InterruptedException { + final AtomicInteger count = new AtomicInteger(); + ConnectableObservable connectable = Observable.create(new OnSubscribeFunc() { + @Override + public Subscription onSubscribe(final Observer observer) { + count.incrementAndGet(); + final BooleanSubscription subscription = new BooleanSubscription(); + new Thread(new Runnable() { + @Override + public void run() { + observer.onNext("first"); + observer.onNext("last"); + observer.onCompleted(); + } + }).start(); + return subscription; + } + }).publishLast(); + + // subscribe once + final CountDownLatch latch = new CountDownLatch(1); + connectable.subscribe(new Action1() { + @Override + public void call(String value) { + assertEquals("last", value); + latch.countDown(); + } + }); + + // subscribe twice + connectable.subscribe(new Action1() { + @Override + public void call(String _) {} + }); + + Subscription subscription = connectable.connect(); + assertTrue(latch.await(1000, TimeUnit.MILLISECONDS)); + assertEquals(1, count.get()); + subscription.unsubscribe(); + } + @Test public void testReplay() throws InterruptedException { final AtomicInteger counter = new AtomicInteger(); From 490ef8663965a016270b74a293c8e739ec5d98d1 Mon Sep 17 00:00:00 2001 From: John Marks Date: Wed, 25 Sep 2013 21:00:24 +0100 Subject: [PATCH 9/9] Removed static variant of refCount --- .../rx/observables/ConnectableObservable.java | 12 +-- .../src/test/java/rx/RefCountTests.java | 84 ++++++------------- 2 files changed, 26 insertions(+), 70 deletions(-) diff --git a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java index a208673028..1595c31195 100644 --- a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java +++ b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java @@ -54,16 +54,6 @@ protected ConnectableObservable(OnSubscribeFunc onSubscribe) { * @return a {@link Observable} */ public Observable refCount() { - return refCount(this); - } - - /** - * Returns an observable sequence that stays connected to the source as long - * as there is at least one subscription to the observable sequence. - * @return a {@link Observable} - * @param that a {@link ConnectableObservable} - */ - public static Observable refCount(ConnectableObservable that) { - return Observable.create(OperationRefCount.refCount(that)); + return Observable.create(OperationRefCount.refCount(this)); } } diff --git a/rxjava-core/src/test/java/rx/RefCountTests.java b/rxjava-core/src/test/java/rx/RefCountTests.java index dae95bf265..bf035e0aa4 100644 --- a/rxjava-core/src/test/java/rx/RefCountTests.java +++ b/rxjava-core/src/test/java/rx/RefCountTests.java @@ -3,10 +3,13 @@ import org.junit.Before; import org.junit.Test; import org.mockito.MockitoAnnotations; -import rx.observables.ConnectableObservable; import rx.subscriptions.Subscriptions; +import rx.util.functions.Action0; -import static org.mockito.Mockito.*; +import java.util.concurrent.atomic.AtomicInteger; + +import static org.junit.Assert.assertEquals; +import static org.mockito.Mockito.mock; public class RefCountTests { @@ -16,67 +19,30 @@ public void setUp() { } @Test - public void subscriptionToUnderlyingOnFirstSubscription() { - @SuppressWarnings("unchecked") - ConnectableObservable connectable = mock(ConnectableObservable.class); - Observable refCounted = ConnectableObservable.refCount(connectable); - @SuppressWarnings("unchecked") - Observer observer = mock(Observer.class); - when(connectable.subscribe(any(Observer.class))).thenReturn(Subscriptions.empty()); - when(connectable.connect()).thenReturn(Subscriptions.empty()); - refCounted.subscribe(observer); - verify(connectable, times(1)).subscribe(any(Observer.class)); - verify(connectable, times(1)).connect(); - } - - @Test - public void noSubscriptionToUnderlyingOnSecondSubscription() { - @SuppressWarnings("unchecked") - ConnectableObservable connectable = mock(ConnectableObservable.class); - Observable refCounted = ConnectableObservable.refCount(connectable); - @SuppressWarnings("unchecked") - Observer observer = mock(Observer.class); - when(connectable.subscribe(any(Observer.class))).thenReturn(Subscriptions.empty()); - when(connectable.connect()).thenReturn(Subscriptions.empty()); - refCounted.subscribe(observer); - refCounted.subscribe(observer); - verify(connectable, times(2)).subscribe(any(Observer.class)); - verify(connectable, times(1)).connect(); - } - - @Test - public void unsubscriptionFromUnderlyingOnLastUnsubscription() { - @SuppressWarnings("unchecked") - ConnectableObservable connectable = mock(ConnectableObservable.class); - Observable refCounted = ConnectableObservable.refCount(connectable); - @SuppressWarnings("unchecked") - Observer observer = mock(Observer.class); - Subscription underlying = mock(Subscription.class); - when(connectable.subscribe(any(Observer.class))).thenReturn(underlying); - Subscription connection = mock(Subscription.class); - when(connectable.connect()).thenReturn(connection); - Subscription first = refCounted.subscribe(observer); - first.unsubscribe(); - verify(underlying, times(1)).unsubscribe(); - verify(connection, times(1)).unsubscribe(); - } - - @Test - public void noUnsubscriptionFromUnderlyingOnFirstUnsubscription() { - @SuppressWarnings("unchecked") - ConnectableObservable connectable = mock(ConnectableObservable.class); - Observable refCounted = ConnectableObservable.refCount(connectable); - @SuppressWarnings("unchecked") + public void onlyFirstShouldSubscribeAndLastUnsubscribe() { + final AtomicInteger subscriptionCount = new AtomicInteger(); + final AtomicInteger unsubscriptionCount = new AtomicInteger(); + Observable observable = Observable.create(new Observable.OnSubscribeFunc() { + @Override + public Subscription onSubscribe(Observer observer) { + subscriptionCount.incrementAndGet(); + return Subscriptions.create(new Action0() { + @Override + public void call() { + unsubscriptionCount.incrementAndGet(); + } + }); + } + }); + Observable refCounted = observable.publish().refCount(); Observer observer = mock(Observer.class); - Subscription underlying = mock(Subscription.class); - when(connectable.subscribe(any(Observer.class))).thenReturn(underlying); - Subscription connection = mock(Subscription.class); - when(connectable.connect()).thenReturn(connection); Subscription first = refCounted.subscribe(observer); + assertEquals(1, subscriptionCount.get()); Subscription second = refCounted.subscribe(observer); + assertEquals(1, subscriptionCount.get()); first.unsubscribe(); + assertEquals(0, unsubscriptionCount.get()); second.unsubscribe(); - verify(underlying, times(2)).unsubscribe(); - verify(connection, times(1)).unsubscribe(); + assertEquals(1, unsubscriptionCount.get()); } }